@konitif/workbench 0.284.1

package/dist/domain/composition/dockArrangement.js

@@ -0,0 +1,304 @@
+export const DOCK_ARRANGEMENT_SCHEMA_VERSION = 1;
+export function createDockArrangement(input) {
+    const children = (input.entities ?? [])
+        .map(createDockArrangementEntityNode)
+        .filter((node) => node !== null);
+    const activeChild = children.find((child) => child.entity.id === input.activeEntityId) ?? children[0] ?? null;
+    return {
+        schemaVersion: DOCK_ARRANGEMENT_SCHEMA_VERSION,
+        root: {
+            nodeType: 'group',
+            nodeId: normalizeId(input.id) || 'dock-root',
+            presentation: input.presentation ?? 'tabs',
+            axis: normalizeGroupAxis(input.presentation ?? 'tabs', input.axis),
+            children,
+            activeChildId: activeChild?.nodeId ?? null
+        }
+    };
+}
+export function createDockArrangementEntityNode(entity) {
+    const normalizedEntity = normalizeDockableEntity(entity);
+    if (!normalizedEntity) {
+        return null;
+    }
+    return {
+        nodeType: 'entity',
+        nodeId: `entity:${getDockableEntityKey(normalizedEntity)}`,
+        entity: normalizedEntity
+    };
+}
+export function createDockArrangementGroup(input) {
+    const children = input.children ?? [];
+    return {
+        nodeType: 'group',
+        nodeId: normalizeId(input.id) || 'dock-group',
+        presentation: input.presentation,
+        axis: normalizeGroupAxis(input.presentation, input.axis),
+        children,
+        activeChildId: normalizeActiveChildId(input.activeChildId, children),
+        ...(input.presentation === 'split' && input.sizes
+            ? { sizes: normalizeSizes(input.sizes, children.length) }
+            : {})
+    };
+}
+export function getDockableEntityKey(entity) {
+    return `${entity.kind}:${normalizeId(entity.id)}`;
+}
+export function listDockArrangementEntities(arrangement) {
+    const entities = [];
+    visitDockArrangement(arrangement.root, (node) => {
+        if (node.nodeType === 'entity') {
+            entities.push(node.entity);
+        }
+    });
+    return entities;
+}
+export function findDockArrangementGroup(arrangement, groupId) {
+    const normalizedGroupId = normalizeId(groupId);
+    let match = null;
+    visitDockArrangement(arrangement.root, (node) => {
+        if (!match && node.nodeType === 'group' && node.nodeId === normalizedGroupId) {
+            match = node;
+        }
+    });
+    return match;
+}
+export function upsertDockArrangementEntity(arrangement, entity, placement = {}) {
+    const entityNode = createDockArrangementEntityNode(entity);
+    if (!entityNode) {
+        return arrangement;
+    }
+    const entityKey = getDockableEntityKey(entityNode.entity);
+    const withoutEntity = removeEntityNode(arrangement.root, entityKey);
+    const targetGroupId = normalizeId(placement.targetGroupId ?? '') || withoutEntity.nodeId;
+    const nextRoot = insertEntityNode(withoutEntity, targetGroupId, entityNode, placement);
+    if (nextRoot === withoutEntity) {
+        return arrangement;
+    }
+    return {
+        ...arrangement,
+        root: nextRoot
+    };
+}
+export function removeDockArrangementEntity(arrangement, entity) {
+    const entityKey = getDockableEntityKey(entity);
+    const root = removeEntityNode(arrangement.root, entityKey);
+    return root === arrangement.root ? arrangement : { ...arrangement, root };
+}
+export function setDockArrangementActiveEntity(arrangement, entity) {
+    const entityKey = getDockableEntityKey(entity);
+    const root = activateEntityNode(arrangement.root, entityKey).node;
+    return root === arrangement.root ? arrangement : { ...arrangement, root };
+}
+export function createDockArrangementFromContainerRuntimeState(state, entityKind, presentation = 'tabs') {
+    return createDockArrangement({
+        id: state.id,
+        presentation,
+        axis: presentation === 'tabs' ? 'tabs' : 'vertical',
+        entities: state.entityIds.map((id) => ({ id, kind: entityKind })),
+        activeEntityId: state.activeEntityId
+    });
+}
+export function projectDockArrangementToContainerRuntimeState(arrangement, fallback) {
+    const entities = listDockArrangementEntities(arrangement);
+    const activeEntity = resolveActiveDockArrangementEntity(arrangement.root);
+    return {
+        id: fallback.id,
+        kind: fallback.kind,
+        isVisible: fallback.isVisible,
+        activeEntityId: activeEntity?.id ?? entities[0]?.id ?? null,
+        entityIds: entities.map((entity) => entity.id)
+    };
+}
+export function validateDockArrangement(arrangement) {
+    const issues = [];
+    const nodeIds = new Set();
+    const entityKeys = new Set();
+    visitDockArrangement(arrangement.root, (node) => {
+        if (!normalizeId(node.nodeId)) {
+            issues.push({ code: 'empty-node-id', nodeId: node.nodeId });
+        }
+        else if (nodeIds.has(node.nodeId)) {
+            issues.push({ code: 'duplicate-node-id', nodeId: node.nodeId });
+        }
+        else {
+            nodeIds.add(node.nodeId);
+        }
+        if (node.nodeType === 'entity') {
+            const entityKey = getDockableEntityKey(node.entity);
+            if (!normalizeId(node.entity.id)) {
+                issues.push({ code: 'empty-entity-id', nodeId: node.nodeId, entityKey });
+            }
+            else if (entityKeys.has(entityKey)) {
+                issues.push({ code: 'duplicate-entity', nodeId: node.nodeId, entityKey });
+            }
+            else {
+                entityKeys.add(entityKey);
+            }
+            return;
+        }
+        if (node.activeChildId !== null && !node.children.some((child) => child.nodeId === node.activeChildId)) {
+            issues.push({ code: 'invalid-active-child', nodeId: node.nodeId });
+        }
+        if (!isAxisCompatible(node.presentation, node.axis)) {
+            issues.push({ code: 'invalid-axis', nodeId: node.nodeId });
+        }
+        if (node.sizes && node.sizes.length !== node.children.length) {
+            issues.push({ code: 'invalid-size-count', nodeId: node.nodeId });
+        }
+    });
+    return issues;
+}
+function removeEntityNode(group, entityKey) {
+    let changed = false;
+    const children = group.children.flatMap((child) => {
+        if (child.nodeType === 'entity') {
+            if (getDockableEntityKey(child.entity) === entityKey) {
+                changed = true;
+                return [];
+            }
+            return [child];
+        }
+        const nextChild = removeEntityNode(child, entityKey);
+        changed ||= nextChild !== child;
+        return [nextChild];
+    });
+    if (!changed) {
+        return group;
+    }
+    return {
+        ...group,
+        children,
+        activeChildId: normalizeActiveChildId(group.activeChildId, children),
+        ...(group.sizes ? { sizes: normalizeSizes(group.sizes, children.length) } : {})
+    };
+}
+function insertEntityNode(group, targetGroupId, entityNode, placement) {
+    if (group.nodeId === targetGroupId) {
+        const children = insertNode(group.children, entityNode, placement);
+        return {
+            ...group,
+            children,
+            activeChildId: placement.activate === false
+                ? normalizeActiveChildId(group.activeChildId, children)
+                : entityNode.nodeId,
+            ...(group.sizes ? { sizes: normalizeSizes(group.sizes, children.length) } : {})
+        };
+    }
+    let changed = false;
+    const children = group.children.map((child) => {
+        if (child.nodeType === 'entity') {
+            return child;
+        }
+        const nextChild = insertEntityNode(child, targetGroupId, entityNode, placement);
+        changed ||= nextChild !== child;
+        return nextChild;
+    });
+    return changed ? { ...group, children } : group;
+}
+function insertNode(children, node, placement) {
+    const beforeId = normalizeId(placement.beforeEntityId ?? '');
+    const afterId = normalizeId(placement.afterEntityId ?? '');
+    const beforeIndex = beforeId ? children.findIndex((child) => matchesEntityId(child, beforeId)) : -1;
+    const afterIndex = afterId ? children.findIndex((child) => matchesEntityId(child, afterId)) : -1;
+    if (beforeIndex >= 0) {
+        return [...children.slice(0, beforeIndex), node, ...children.slice(beforeIndex)];
+    }
+    if (afterIndex >= 0) {
+        return [...children.slice(0, afterIndex + 1), node, ...children.slice(afterIndex + 1)];
+    }
+    return [...children, node];
+}
+function activateEntityNode(group, entityKey) {
+    for (const child of group.children) {
+        if (child.nodeType === 'entity') {
+            if (getDockableEntityKey(child.entity) === entityKey) {
+                if (group.activeChildId === child.nodeId) {
+                    return { node: group, found: true };
+                }
+                return { node: { ...group, activeChildId: child.nodeId }, found: true };
+            }
+            continue;
+        }
+        const result = activateEntityNode(child, entityKey);
+        if (result.found) {
+            const children = group.children.map((candidate) => candidate === child ? result.node : candidate);
+            return {
+                node: {
+                    ...group,
+                    children,
+                    activeChildId: child.nodeId
+                },
+                found: true
+            };
+        }
+    }
+    return { node: group, found: false };
+}
+function resolveActiveDockArrangementEntity(node) {
+    if (node.nodeType === 'entity') {
+        return node.entity;
+    }
+    const activeChild = node.children.find((child) => child.nodeId === node.activeChildId) ?? node.children[0];
+    return activeChild ? resolveActiveDockArrangementEntity(activeChild) : null;
+}
+function normalizeDockableEntity(entity) {
+    const id = normalizeId(entity.id);
+    if (!id) {
+        return null;
+    }
+    return {
+        ...entity,
+        id,
+        capabilityId: normalizeOptionalId(entity.capabilityId),
+        sourceContainerId: normalizeOptionalId(entity.sourceContainerId),
+        contextToolIds: normalizeIds(entity.contextToolIds ?? [])
+    };
+}
+function normalizeActiveChildId(activeChildId, children) {
+    const normalizedId = normalizeId(activeChildId ?? '');
+    return children.some((child) => child.nodeId === normalizedId) ? normalizedId : children[0]?.nodeId ?? null;
+}
+function normalizeSizes(sizes, childCount) {
+    if (childCount === 0) {
+        return [];
+    }
+    const positiveSizes = Array.from({ length: childCount }, (_, index) => {
+        const value = sizes[index];
+        return Number.isFinite(value) && value > 0 ? value : 1;
+    });
+    const total = positiveSizes.reduce((sum, value) => sum + value, 0);
+    return positiveSizes.map((value) => value / total);
+}
+function normalizeGroupAxis(presentation, axis) {
+    if (presentation === 'tabs') {
+        return 'tabs';
+    }
+    if (axis === 'horizontal' || axis === 'vertical') {
+        return axis;
+    }
+    return 'vertical';
+}
+function isAxisCompatible(presentation, axis) {
+    return presentation === 'tabs'
+        ? axis === 'tabs'
+        : axis === 'horizontal' || axis === 'vertical';
+}
+function matchesEntityId(node, entityId) {
+    return node.nodeType === 'entity' && node.entity.id === entityId;
+}
+function normalizeIds(values) {
+    return [...new Set(values.map(normalizeId).filter(Boolean))];
+}
+function normalizeOptionalId(value) {
+    return normalizeId(value ?? '') || null;
+}
+function normalizeId(value) {
+    return value.trim();
+}
+function visitDockArrangement(node, visitor) {
+    visitor(node);
+    if (node.nodeType === 'group') {
+        node.children.forEach((child) => visitDockArrangement(child, visitor));
+    }
+}

package/dist/domain/composition/docking.d.ts

@@ -0,0 +1,68 @@
+export type DockableEntityKind = 'panel' | 'tool-instance' | 'shell-widget' | 'tool-widget' | 'widget-placement';
+export type DockContainerKind = 'workspace-panel-stack' | 'workspace-split' | 'shell-region' | 'tool-side' | 'widget-zone';
+export type DockAxis = 'horizontal' | 'vertical' | 'grid' | 'tabs';
+export type DockMode = 'append' | 'reorder' | 'tab' | 'split' | 'stack' | 'replace';
+export type DockPlanRejectionReason = 'invalid-entity' | 'invalid-container' | 'unsupported-kind' | 'unsupported-mode' | 'missing-context' | 'already-connected';
+export interface DockableEntity {
+    id: string;
+    kind: DockableEntityKind;
+    capabilityId?: string | null;
+    sourceContainerId?: string | null;
+    contextToolIds?: string[];
+}
+export interface DockContainer {
+    id: string;
+    kind: DockContainerKind;
+    acceptedEntityKinds: DockableEntityKind[];
+    axis: DockAxis;
+    supportedModes: DockMode[];
+    contextToolIds?: string[];
+}
+export interface DockContainerRuntimeState {
+    id: string;
+    kind?: DockContainerKind;
+    isVisible: boolean;
+    activeEntityId: string | null;
+    entityIds: string[];
+}
+export type DockContainerRuntimeStateById = Record<string, DockContainerRuntimeState | undefined>;
+export interface DockContext {
+    availableToolIds?: Iterable<string>;
+    connectedCapabilityIds?: Iterable<string>;
+    connectedEntityIds?: Iterable<string>;
+}
+export interface DockPlacement {
+    beforeEntityId?: string | null;
+    afterEntityId?: string | null;
+}
+export interface DockPlan {
+    accepted: boolean;
+    entityId: string;
+    containerId: string;
+    mode: DockMode;
+    placement: DockPlacement;
+    reason?: DockPlanRejectionReason;
+}
+export interface CreateDockPlanInput {
+    entity: DockableEntity;
+    container: DockContainer;
+    mode: DockMode;
+    placement?: DockPlacement | null;
+    context?: DockContext;
+    allowConnectedCapability?: boolean;
+    allowConnectedEntity?: boolean;
+}
+export declare function createDockContainerRuntimeState(input: {
+    id: string;
+    kind?: DockContainerKind;
+    isVisible?: boolean;
+    entityIds?: string[];
+    activeEntityId?: string | null;
+}): DockContainerRuntimeState;
+export declare function normalizeDockContainerRuntimeState(value: unknown, fallback: DockContainerRuntimeState): DockContainerRuntimeState;
+export declare function setDockContainerVisible(stateById: DockContainerRuntimeStateById, containerId: string, isVisible: boolean): DockContainerRuntimeStateById;
+export declare function dockEntityInContainerRuntimeState(state: DockContainerRuntimeState, entityId: string, placement?: DockPlacement | null | undefined): DockContainerRuntimeState;
+export declare function normalizeDockPlacement(placement: DockPlacement | null | undefined): DockPlacement;
+export declare function hasDockPlacement(placement: DockPlacement | null | undefined): boolean;
+export declare function insertDockableEntityId(entityIds: string[], entityId: string, placement?: DockPlacement | null | undefined): string[];
+export declare function createDockPlan(input: CreateDockPlanInput): DockPlan;

package/dist/domain/composition/docking.js

@@ -0,0 +1,187 @@
+export function createDockContainerRuntimeState(input) {
+    const entityIds = normalizeEntityIds(input.entityIds ?? []);
+    const activeEntityId = normalizeActiveEntityId(input.activeEntityId, entityIds);
+    return {
+        id: input.id.trim(),
+        kind: input.kind,
+        isVisible: input.isVisible ?? entityIds.length > 0,
+        activeEntityId,
+        entityIds
+    };
+}
+export function normalizeDockContainerRuntimeState(value, fallback) {
+    if (!isRecord(value)) {
+        return fallback;
+    }
+    const entityIds = Array.isArray(value.entityIds)
+        ? normalizeEntityIds(value.entityIds.filter((entityId) => typeof entityId === 'string'))
+        : fallback.entityIds;
+    const activeEntityId = normalizeActiveEntityId(typeof value.activeEntityId === 'string' ? value.activeEntityId : fallback.activeEntityId, entityIds);
+    return {
+        id: typeof value.id === 'string' && value.id.trim() ? value.id.trim() : fallback.id,
+        kind: isDockContainerKind(value.kind) ? value.kind : fallback.kind,
+        isVisible: typeof value.isVisible === 'boolean' ? value.isVisible : fallback.isVisible,
+        activeEntityId,
+        entityIds
+    };
+}
+export function setDockContainerVisible(stateById, containerId, isVisible) {
+    const normalizedContainerId = containerId.trim();
+    const state = stateById[normalizedContainerId];
+    if (!state || state.isVisible === isVisible) {
+        return stateById;
+    }
+    return {
+        ...stateById,
+        [normalizedContainerId]: {
+            ...state,
+            isVisible
+        }
+    };
+}
+export function dockEntityInContainerRuntimeState(state, entityId, placement = {}) {
+    const entityIds = insertDockableEntityId(state.entityIds, entityId, placement);
+    return {
+        ...state,
+        isVisible: true,
+        activeEntityId: entityId.trim() || state.activeEntityId,
+        entityIds
+    };
+}
+export function normalizeDockPlacement(placement) {
+    return {
+        beforeEntityId: normalizeOptionalId(placement?.beforeEntityId),
+        afterEntityId: normalizeOptionalId(placement?.afterEntityId)
+    };
+}
+export function hasDockPlacement(placement) {
+    const normalizedPlacement = normalizeDockPlacement(placement);
+    return Boolean(normalizedPlacement.beforeEntityId || normalizedPlacement.afterEntityId);
+}
+export function insertDockableEntityId(entityIds, entityId, placement = {}) {
+    const normalizedEntityId = entityId.trim();
+    if (!normalizedEntityId) {
+        return entityIds;
+    }
+    const baseEntityIds = entityIds.filter((currentEntityId) => currentEntityId !== normalizedEntityId);
+    const normalizedPlacement = normalizeDockPlacement(placement);
+    if (normalizedPlacement.beforeEntityId) {
+        const beforeIndex = baseEntityIds.indexOf(normalizedPlacement.beforeEntityId);
+        if (beforeIndex >= 0) {
+            return [
+                ...baseEntityIds.slice(0, beforeIndex),
+                normalizedEntityId,
+                ...baseEntityIds.slice(beforeIndex)
+            ];
+        }
+    }
+    if (normalizedPlacement.afterEntityId) {
+        const afterIndex = baseEntityIds.indexOf(normalizedPlacement.afterEntityId);
+        if (afterIndex >= 0) {
+            return [
+                ...baseEntityIds.slice(0, afterIndex + 1),
+                normalizedEntityId,
+                ...baseEntityIds.slice(afterIndex + 1)
+            ];
+        }
+    }
+    return [...baseEntityIds, normalizedEntityId];
+}
+export function createDockPlan(input) {
+    const entityId = input.entity.id.trim();
+    const containerId = input.container.id.trim();
+    const placement = normalizeDockPlacement(input.placement);
+    if (!entityId) {
+        return rejectDockPlan(entityId, containerId, input.mode, placement, 'invalid-entity');
+    }
+    if (!containerId) {
+        return rejectDockPlan(entityId, containerId, input.mode, placement, 'invalid-container');
+    }
+    if (!input.container.acceptedEntityKinds.includes(input.entity.kind)) {
+        return rejectDockPlan(entityId, containerId, input.mode, placement, 'unsupported-kind');
+    }
+    if (!input.container.supportedModes.includes(input.mode)) {
+        return rejectDockPlan(entityId, containerId, input.mode, placement, 'unsupported-mode');
+    }
+    if (!hasRequiredContext(input.entity.contextToolIds, input.context?.availableToolIds)) {
+        return rejectDockPlan(entityId, containerId, input.mode, placement, 'missing-context');
+    }
+    if (!hasRequiredContext(input.container.contextToolIds, input.context?.availableToolIds)) {
+        return rejectDockPlan(entityId, containerId, input.mode, placement, 'missing-context');
+    }
+    const connectedEntityIds = toSet(input.context?.connectedEntityIds);
+    const connectedCapabilityIds = toSet(input.context?.connectedCapabilityIds);
+    const capabilityId = input.entity.capabilityId?.trim() || null;
+    if (!input.allowConnectedEntity && connectedEntityIds.has(entityId)) {
+        return rejectDockPlan(entityId, containerId, input.mode, placement, 'already-connected');
+    }
+    if (!input.allowConnectedCapability && capabilityId && connectedCapabilityIds.has(capabilityId)) {
+        return rejectDockPlan(entityId, containerId, input.mode, placement, 'already-connected');
+    }
+    return {
+        accepted: true,
+        entityId,
+        containerId,
+        mode: input.mode,
+        placement
+    };
+}
+function rejectDockPlan(entityId, containerId, mode, placement, reason) {
+    return {
+        accepted: false,
+        entityId,
+        containerId,
+        mode,
+        placement,
+        reason
+    };
+}
+function normalizeOptionalId(value) {
+    const normalizedValue = value?.trim();
+    return normalizedValue ? normalizedValue : null;
+}
+function hasRequiredContext(requiredToolIds, availableToolIds) {
+    const requiredIds = requiredToolIds?.map((toolId) => toolId.trim()).filter(Boolean) ?? [];
+    if (requiredIds.length === 0) {
+        return true;
+    }
+    const availableIds = toSet(availableToolIds);
+    return requiredIds.some((toolId) => availableIds.has(toolId));
+}
+function toSet(values) {
+    const normalizedValues = new Set();
+    for (const value of values ?? []) {
+        const normalizedValue = value.trim();
+        if (normalizedValue) {
+            normalizedValues.add(normalizedValue);
+        }
+    }
+    return normalizedValues;
+}
+function normalizeEntityIds(entityIds) {
+    const normalizedEntityIds = [];
+    for (const entityId of entityIds) {
+        const normalizedEntityId = entityId.trim();
+        if (normalizedEntityId && !normalizedEntityIds.includes(normalizedEntityId)) {
+            normalizedEntityIds.push(normalizedEntityId);
+        }
+    }
+    return normalizedEntityIds;
+}
+function normalizeActiveEntityId(activeEntityId, entityIds) {
+    const normalizedActiveEntityId = activeEntityId?.trim();
+    if (normalizedActiveEntityId && entityIds.includes(normalizedActiveEntityId)) {
+        return normalizedActiveEntityId;
+    }
+    return entityIds[0] ?? null;
+}
+function isDockContainerKind(value) {
+    return (value === 'workspace-panel-stack' ||
+        value === 'workspace-split' ||
+        value === 'shell-region' ||
+        value === 'tool-side' ||
+        value === 'widget-zone');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/domain/design-system/themeSession.d.ts

@@ -0,0 +1,12 @@
+export declare const DESIGN_SYSTEM_THEME_SESSION_VERSION = 1;
+export type DesignSystemThemeMode = 'dark' | 'light';
+export interface DesignSystemThemeSession {
+    version: typeof DESIGN_SYSTEM_THEME_SESSION_VERSION;
+    mode: DesignSystemThemeMode;
+    draftValues: Record<string, string>;
+    draftPast: Array<Record<string, string>>;
+    draftFuture: Array<Record<string, string>>;
+}
+export declare function createDesignSystemThemeSession(input?: Partial<DesignSystemThemeSession>): DesignSystemThemeSession;
+export declare function normalizeDesignSystemThemeSession(input: unknown): DesignSystemThemeSession | null;
+export declare function normalizeDesignSystemThemeMode(input: unknown): DesignSystemThemeMode;

package/dist/domain/design-system/themeSession.js

@@ -0,0 +1,42 @@
+export const DESIGN_SYSTEM_THEME_SESSION_VERSION = 1;
+export function createDesignSystemThemeSession(input = {}) {
+    return {
+        version: DESIGN_SYSTEM_THEME_SESSION_VERSION,
+        mode: normalizeDesignSystemThemeMode(input.mode),
+        draftValues: cloneDraftValues(input.draftValues),
+        draftPast: cloneDraftHistory(input.draftPast),
+        draftFuture: cloneDraftHistory(input.draftFuture)
+    };
+}
+export function normalizeDesignSystemThemeSession(input) {
+    if (!isRecord(input)) {
+        return null;
+    }
+    return createDesignSystemThemeSession({
+        mode: normalizeDesignSystemThemeMode(input.mode),
+        draftValues: normalizeDraftValues(input.draftValues),
+        draftPast: normalizeDraftHistory(input.draftPast),
+        draftFuture: normalizeDraftHistory(input.draftFuture)
+    });
+}
+export function normalizeDesignSystemThemeMode(input) {
+    return input === 'light' ? 'light' : 'dark';
+}
+function normalizeDraftHistory(input) {
+    return Array.isArray(input) ? input.map(normalizeDraftValues) : [];
+}
+function cloneDraftHistory(input) {
+    return input?.map(cloneDraftValues) ?? [];
+}
+function normalizeDraftValues(input) {
+    if (!isRecord(input)) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(input).filter((entry) => typeof entry[1] === 'string'));
+}
+function cloneDraftValues(input) {
+    return input ? { ...input } : {};
+}
+function isRecord(input) {
+    return Boolean(input) && typeof input === 'object' && !Array.isArray(input);
+}