@endge/core 1.2.5 → 1.2.7

package/dist/domain/types/component/sfc/ports-source.types.d.ts

@@ -0,0 +1,44 @@
+import { RComponentDiagnostic } from '../component-core.types';
+import { ComponentSFCEventSource, ComponentSFCPortManifest, ComponentSFCPortRole } from './ports.types';
+import { RComponentSFC_SourceRange } from './location.types';
+export interface ComponentSFCPortsSourceProjection {
+    editable: boolean;
+    message?: string;
+    bindingName: string | null;
+    manifest: ComponentSFCPortManifest;
+    sourceRange?: RComponentSFC_SourceRange;
+    diagnostics: RComponentDiagnostic[];
+}
+/** Source-preserving CRUD used by the visual Ports and Events editors. */
+export type ComponentSFCPortsSourcePatch = {
+    type: 'upsert-port';
+    role: ComponentSFCPortRole;
+    name: string;
+    /** Complete factory expression, for example `event<RowEvent>()`. */
+    declaration: string;
+} | {
+    type: 'remove-port';
+    role: ComponentSFCPortRole;
+    name: string;
+} | {
+    type: 'set-event';
+    name: string;
+    payloadType: string;
+    from?: ComponentSFCEventSource | null;
+    /** Raw Action expression (`{ identity: ... }` or `typescript({...})`). */
+    actionSource?: string | null;
+} | {
+    type: 'remove-event-action';
+    name: string;
+} | {
+    type: 'set-forward';
+    /** Raw value of `forward`; null removes the section. */
+    declaration: string | null;
+};
+export interface ComponentSFCPortsSourcePatchResult {
+    ok: boolean;
+    changed: boolean;
+    source: string;
+    projection: ComponentSFCPortsSourceProjection;
+    message?: string;
+}

package/dist/domain/types/component/sfc/ports.types.d.ts

@@ -0,0 +1,200 @@
+import { RComponentContractInput } from '../component-core.types';
+import { RComponentSFC_IR_Value } from './ir.types';
+import { RComponentSFC_SourceRange } from './location.types';
+export type ComponentSFCPortRole = 'require' | 'provides' | 'emits';
+export type ComponentSFCPortKind = 'computation' | 'component' | 'action' | 'event';
+/** Public child port selected by a compile-time `definePorts.forward` rule. */
+export interface ComponentSFCPortForwardOrigin {
+    nodeId: string;
+    ref?: string;
+    componentIdentity?: string;
+    componentTag: string;
+    portName: string;
+}
+/** Normalized selector for one port direction inside a forward rule. */
+export interface ComponentSFCPortForwardSelector {
+    include: '*' | string[];
+    exclude: string[];
+    rename: Record<string, string>;
+    namespace?: 'none' | 'ref' | string;
+}
+/** Compile-time forwarding rule persisted in the Component SFC artifact. */
+export interface ComponentSFCPortForwardRule {
+    from: '*' | string[];
+    ports: Partial<Record<ComponentSFCPortRole, ComponentSFCPortForwardSelector>>;
+    namespace: 'none' | 'ref' | string;
+    sourceRange?: RComponentSFC_SourceRange;
+}
+/** Default provider descriptor, supplied by the domain build boundary. */
+export type ComponentSFCPortProviderDescriptor = {
+    kind: 'computation';
+    identity: string;
+    active: boolean;
+    input: {
+        type: string;
+        isArray?: boolean;
+        optional?: boolean;
+    } | null;
+    output: {
+        type: string;
+        isArray?: boolean;
+        optional?: boolean;
+    } | null;
+} | {
+    kind: 'component';
+    identity: string;
+    active: boolean;
+    inputs: RComponentContractInput[];
+} | {
+    kind: 'action';
+    identity: string;
+    active: boolean;
+    input: {
+        type: string;
+        isArray?: boolean;
+        optional?: boolean;
+    } | null;
+    output: {
+        type: string;
+        isArray?: boolean;
+        optional?: boolean;
+    } | null;
+};
+/** Computation port declared by `computation<Input, Output>`. */
+export interface ComponentSFCComputationPort {
+    kind: 'computation';
+    name: string;
+    defaultIdentity: string;
+    inputType: string;
+    outputType: string;
+    forwardedFrom?: ComponentSFCPortForwardOrigin;
+    sourceRange?: RComponentSFC_SourceRange;
+}
+/** Component port declared by `component<Props>`. */
+export interface ComponentSFCComponentPort {
+    kind: 'component';
+    name: string;
+    tag: string;
+    defaultIdentity: string;
+    propsType: string;
+    inputs: RComponentContractInput[];
+    forwardedFrom?: ComponentSFCPortForwardOrigin;
+    sourceRange?: RComponentSFC_SourceRange;
+}
+/** Callable Action required from the outside or provided by this component. */
+export interface ComponentSFCActionPort {
+    kind: 'action';
+    role: 'require' | 'provides';
+    name: string;
+    inputType: string;
+    outputType: string;
+    defaultIdentity?: string;
+    forwardedFrom?: ComponentSFCPortForwardOrigin;
+    sourceRange?: RComponentSFC_SourceRange;
+}
+/** Multicast notification emitted by this component. */
+export interface ComponentSFCEventPort {
+    kind: 'event';
+    role: 'emits';
+    name: string;
+    /** Human-readable catalog label. Identity remains based on `name`. */
+    displayName?: string;
+    payloadType: string;
+    /** Optional local producer whose Event is republished by this component. */
+    from?: ComponentSFCEventSource;
+    /** Optional reaction executed after the Event occurrence is published. */
+    action?: ComponentSFCEventAction;
+    forwardedFrom?: ComponentSFCPortForwardOrigin;
+    sourceRange?: RComponentSFC_SourceRange;
+}
+/** Literal child Event reference used by `event({ from })`. */
+export interface ComponentSFCEventSource {
+    ref: string;
+    event: string;
+}
+/** Renderer-neutral value mapped from an Event payload into Action input. */
+export type ComponentSFCEventInputValue = {
+    kind: 'event';
+    path: string | null;
+} | {
+    kind: 'literal';
+    value: unknown;
+} | {
+    kind: 'array';
+    items: ComponentSFCEventInputValue[];
+} | {
+    kind: 'object';
+    entries: Record<string, ComponentSFCEventInputValue>;
+};
+/** One Action selected directly in Component SFC Source. */
+export interface ComponentSFCEventDirectAction {
+    kind: 'action';
+    identity: string;
+    input?: ComponentSFCEventInputValue;
+}
+/** Sandboxed TypeScript reaction. Its result is a validated list of effects. */
+export interface ComponentSFCEventTypescriptAction {
+    kind: 'typescript';
+    inputs: Record<string, {
+        kind: 'event';
+        path: string | null;
+    }>;
+    /** Original `typescript({...})` expression for source projection/editor round-trips. */
+    definitionSource?: string;
+    source: string;
+    emittedEvents: string[];
+}
+export type ComponentSFCEventAction = ComponentSFCEventDirectAction | ComponentSFCEventTypescriptAction;
+export interface ComponentSFCEventRuntimeSource {
+    nodeId: string;
+    ref?: string;
+    componentIdentity?: string;
+    componentTag: string;
+    target?: {
+        type: string;
+        identity: string;
+        value: unknown;
+    };
+}
+export interface ComponentSFCEventOccurrence<TPayload = unknown> {
+    componentIdentity: string;
+    event: string;
+    payload: TPayload;
+    source?: ComponentSFCEventRuntimeSource;
+}
+export interface ComponentSFCRequiredPorts {
+    computations: ComponentSFCComputationPort[];
+    components: ComponentSFCComponentPort[];
+    actions: ComponentSFCActionPort[];
+}
+export interface ComponentSFCProvidedPorts {
+    actions: ComponentSFCActionPort[];
+}
+export interface ComponentSFCEmittedPorts {
+    events: ComponentSFCEventPort[];
+}
+/** Typed port manifest stored in the compiled ComponentSFC artifact. */
+export interface ComponentSFCPortManifest {
+    require: ComponentSFCRequiredPorts;
+    provides: ComponentSFCProvidedPorts;
+    emits: ComponentSFCEmittedPorts;
+    forward: {
+        rules: ComponentSFCPortForwardRule[];
+    };
+}
+/** One top-level local initialized through a computation port call. */
+export interface RComponentSFC_IR_PortCall {
+    kind: 'computation';
+    local: string;
+    port: string;
+    defaultIdentity: string;
+    input: RComponentSFC_IR_Value;
+    sourceRange?: RComponentSFC_SourceRange;
+}
+/** Marker on a nested Component IR node created from a local component port. */
+export interface RComponentSFC_IR_ComponentPortMarker {
+    kind: 'component';
+    port: string;
+    defaultIdentity: string;
+}
+export declare function createEmptyComponentSFCPortManifest(): ComponentSFCPortManifest;

package/dist/domain/types/component/sfc/props-visual.types.d.ts

@@ -0,0 +1,20 @@
+import { RComponentDiagnostic } from '../component-core.types';
+import { RComponentSFC_IR_Prop } from './ir.types';
+import { RComponentSFC_SourceRange } from './location.types';
+/** Source-backed projection of the SFC public props contract for visual editors. */
+export interface ComponentSFCPropsVisualProjection {
+    mode: 'missing' | 'inline-type' | 'named-type' | 'runtime';
+    editable: boolean;
+    props: RComponentSFC_IR_Prop[];
+    sourceRange: RComponentSFC_SourceRange | null;
+    message?: string;
+}
+/** Result of replacing the editable inline defineProps contract. */
+export interface ComponentSFCPropsSourcePatchResult {
+    ok: boolean;
+    source: string;
+    changed: boolean;
+    projection: ComponentSFCPropsVisualProjection;
+    diagnostics: RComponentDiagnostic[];
+    message?: string;
+}

package/dist/domain/types/component/sfc/source.types.d.ts

@@ -0,0 +1,26 @@
+/** Секция source, которую пользователь видит как вкладку script. */
+export interface RComponentSFCSource_Script {
+    /** Содержимое <script setup>. */
+    content: string;
+}
+/** Секция source, которую пользователь видит как вкладку template. */
+export interface RComponentSFCSource_Template {
+    /** Содержимое <template>. */
+    content: string;
+}
+/** Секция source, которую пользователь видит как вкладку style. */
+export interface RComponentSFCSource_Style {
+    /** Содержимое <style>. */
+    content: string;
+    /** Флаг scoped-стилей в духе Vue/Nova SFC. */
+    scoped: boolean;
+}
+/** Разложенное представление SFC для вкладок конфигуратора. */
+export interface RComponentSFCSource_Parts {
+    /** Script-секция компонента. */
+    script: RComponentSFCSource_Script;
+    /** Template-секция компонента. */
+    template: RComponentSFCSource_Template;
+    /** Style-секция компонента. */
+    style: RComponentSFCSource_Style;
+}

package/dist/domain/types/component/sfc/table-events.types.d.ts

@@ -0,0 +1,75 @@
+export type TableSelectionMode = 'none' | 'single' | 'multiple';
+export type TableRowActivationKind = 'pointer' | 'keyboard';
+export interface TableEventBase {
+    tableId: string;
+}
+export interface TableRowActivatedEvent<TRow extends Record<string, unknown> = Record<string, unknown>> extends TableEventBase {
+    rowId: string;
+    rowIndex: number;
+    row: TRow;
+    columnKey: string | null;
+    activation: TableRowActivationKind;
+}
+export interface TableRowContextMenuRequestedEvent<TRow extends Record<string, unknown> = Record<string, unknown>> extends TableEventBase {
+    rowId: string;
+    rowIndex: number;
+    row: TRow;
+    columnKey: string | null;
+    anchor: {
+        x: number;
+        y: number;
+    };
+}
+export interface TableSelectionChangedEvent<TRow extends Record<string, unknown> = Record<string, unknown>> extends TableEventBase {
+    mode: Exclude<TableSelectionMode, 'none'>;
+    selectedRowIds: string[];
+    selectedRows: TRow[];
+    addedRowIds: string[];
+    removedRowIds: string[];
+}
+export interface TableSortChangedEvent extends TableEventBase {
+    sort: Array<{
+        columnKey: string;
+        direction: 'asc' | 'desc';
+    }>;
+}
+export interface TableColumnVisibilityChangedEvent extends TableEventBase {
+    visibility: Record<string, boolean>;
+    hiddenColumnKeys: string[];
+}
+export interface TableColumnPinChangedEvent extends TableEventBase {
+    left: string[];
+    right: string[];
+}
+export interface TableColumnOrderChangedEvent extends TableEventBase {
+    columnKeys: string[];
+}
+export interface TableColumnSizeChangedEvent extends TableEventBase {
+    sizes: Record<string, number>;
+    changedColumnKey: string | null;
+}
+export interface TablePageChangedEvent extends TableEventBase {
+    pageIndex: number;
+    pageSize: number;
+    pageCount: number;
+}
+export interface TableEventMap {
+    rowActivated: TableRowActivatedEvent;
+    rowContextMenuRequested: TableRowContextMenuRequestedEvent;
+    selectionChanged: TableSelectionChangedEvent;
+    sortChanged: TableSortChangedEvent;
+    columnVisibilityChanged: TableColumnVisibilityChangedEvent;
+    columnPinChanged: TableColumnPinChangedEvent;
+    columnOrderChanged: TableColumnOrderChangedEvent;
+    columnSizeChanged: TableColumnSizeChangedEvent;
+    pageChanged: TablePageChangedEvent;
+}
+export type TableEventName = keyof TableEventMap;
+export interface TableEventDefinition {
+    name: TableEventName;
+    displayName: string;
+    payloadType: string;
+    description: string;
+}
+/** Canonical renderer-neutral Event manifest of the built-in Table tag. */
+export declare const TABLE_EVENT_DEFINITIONS: readonly TableEventDefinition[];

package/dist/domain/types/component/sfc/table-visibility.types.d.ts

@@ -0,0 +1,6 @@
+import { RComponentDiagnostic } from '../component-core.types';
+/** Renderer-neutral начальная видимость колонок Table. */
+export interface ComponentSFCTableColumnVisibilityDescriptor {
+    defaultHidden: string[];
+    diagnostics: RComponentDiagnostic[];
+}

package/dist/domain/types/component/sfc/tag-input-contract.types.d.ts

@@ -0,0 +1,178 @@
+import { RComponentContractInput } from '../component-core.types';
+import { RComponentSFC_IR_Tag } from './ir.types';
+/** Публичный входной параметр renderer-neutral встроенного SFC tag. */
+export type ComponentSFCTagInputContract = Readonly<RComponentContractInput>;
+/**
+ * Data-facing входы встроенных tags для source-aware visual editors.
+ * Presentation-атрибуты остаются в отдельном редакторе атрибутов.
+ */
+export declare const ENDGE_SFC_TAG_INPUT_CONTRACTS: {
+    readonly Text: readonly [{
+        readonly name: "value";
+        readonly type: "string";
+        readonly optional: true;
+    }];
+    readonly DateTime: readonly [{
+        readonly name: "value";
+        readonly type: "Date | string";
+        readonly optional: false;
+    }, {
+        readonly name: "format";
+        readonly type: "string";
+        readonly optional: true;
+    }, {
+        readonly name: "timezone";
+        readonly type: "string";
+        readonly optional: true;
+    }, {
+        readonly name: "empty";
+        readonly type: "string";
+        readonly optional: true;
+    }];
+    readonly Number: readonly [{
+        readonly name: "value";
+        readonly type: "number";
+        readonly optional: false;
+    }, {
+        readonly name: "decimals";
+        readonly type: "number";
+        readonly optional: true;
+    }, {
+        readonly name: "prefix";
+        readonly type: "string";
+        readonly optional: true;
+    }, {
+        readonly name: "suffix";
+        readonly type: "string";
+        readonly optional: true;
+    }, {
+        readonly name: "empty";
+        readonly type: "string";
+        readonly optional: true;
+    }];
+    readonly Icon: readonly [{
+        readonly name: "name";
+        readonly type: "string";
+        readonly optional: false;
+    }];
+    readonly Badge: readonly [{
+        readonly name: "value";
+        readonly type: "string";
+        readonly optional: true;
+    }, {
+        readonly name: "tone";
+        readonly type: "string";
+        readonly optional: true;
+    }];
+    readonly Dot: readonly [{
+        readonly name: "tone";
+        readonly type: "string";
+        readonly optional: true;
+    }];
+    readonly Box: readonly [];
+    readonly Flex: readonly [];
+    readonly Grid: readonly [];
+    readonly Divider: readonly [{
+        readonly name: "orientation";
+        readonly type: "'horizontal' | 'vertical'";
+        readonly optional: true;
+    }];
+    readonly Input: readonly [{
+        readonly name: "value";
+        readonly type: "unknown";
+        readonly optional: true;
+    }, {
+        readonly name: "type";
+        readonly type: "'String' | 'Number' | 'Date' | 'Time' | 'DateTime'";
+        readonly optional: true;
+    }, {
+        readonly name: "placeholder";
+        readonly type: "string";
+        readonly optional: true;
+    }, {
+        readonly name: "min";
+        readonly type: "string | number";
+        readonly optional: true;
+    }, {
+        readonly name: "max";
+        readonly type: "string | number";
+        readonly optional: true;
+    }, {
+        readonly name: "step";
+        readonly type: "string | number";
+        readonly optional: true;
+    }, {
+        readonly name: "readonly";
+        readonly type: "boolean";
+        readonly optional: true;
+    }, {
+        readonly name: "disabled";
+        readonly type: "boolean";
+        readonly optional: true;
+    }];
+    readonly Textarea: readonly [{
+        readonly name: "value";
+        readonly type: "string";
+        readonly optional: true;
+    }, {
+        readonly name: "rows";
+        readonly type: "number";
+        readonly optional: true;
+    }, {
+        readonly name: "placeholder";
+        readonly type: "string";
+        readonly optional: true;
+    }, {
+        readonly name: "readonly";
+        readonly type: "boolean";
+        readonly optional: true;
+    }, {
+        readonly name: "disabled";
+        readonly type: "boolean";
+        readonly optional: true;
+    }];
+    readonly Checkbox: readonly [{
+        readonly name: "checked";
+        readonly type: "boolean";
+        readonly optional: true;
+    }, {
+        readonly name: "label";
+        readonly type: "string";
+        readonly optional: true;
+    }, {
+        readonly name: "readonly";
+        readonly type: "boolean";
+        readonly optional: true;
+    }, {
+        readonly name: "disabled";
+        readonly type: "boolean";
+        readonly optional: true;
+    }];
+    readonly Select: readonly [{
+        readonly name: "value";
+        readonly type: "unknown | unknown[]";
+        readonly optional: true;
+    }, {
+        readonly name: "options";
+        readonly type: "SourceFieldOption[]";
+        readonly optional: false;
+    }, {
+        readonly name: "multiple";
+        readonly type: "boolean";
+        readonly optional: true;
+    }, {
+        readonly name: "placeholder";
+        readonly type: "string";
+        readonly optional: true;
+    }, {
+        readonly name: "readonly";
+        readonly type: "boolean";
+        readonly optional: true;
+    }, {
+        readonly name: "disabled";
+        readonly type: "boolean";
+        readonly optional: true;
+    }];
+};
+/** Возвращает публичные data-входы встроенного SFC tag. */
+export declare function getComponentSFCTagInputContract(tag: RComponentSFC_IR_Tag): readonly ComponentSFCTagInputContract[];

package/dist/domain/types/component/sfc/visual-projection.types.d.ts

@@ -0,0 +1,140 @@
+import { RComponentDiagnostic } from '../component-core.types';
+import { TypeSourceDefinition } from '../../source/type-source.types';
+import { RComponentSFC_IR_Tag } from './ir.types';
+import { RComponentSFC_SourceRange } from './location.types';
+/** Значение SFC source, подготовленное для безопасного отображения в visual editor. */
+export type ComponentSFCVisualSourceValue = {
+    kind: 'boolean';
+    value: boolean;
+} | {
+    kind: 'literal';
+    value: unknown;
+} | {
+    kind: 'expression';
+    source: string;
+};
+/** Один attribute исходного SFC-узла без привязки к конкретному UI framework. */
+export interface ComponentSFCVisualAttribute {
+    name: string;
+    value: ComponentSFCVisualSourceValue;
+    sourceRange?: RComponentSFC_SourceRange;
+}
+/** Редактируемый prop binding единственного управляемого элемента колонки Table. */
+export type ComponentSFCTableCellBindingProjection = ComponentSFCVisualAttribute;
+/** Способ, которым содержимое ячейки представлено в простом visual editor. */
+export type ComponentSFCTableVisualCellTag = Exclude<RComponentSFC_IR_Tag, 'Component' | 'Table' | 'Column' | 'Cell' | 'ColumnMenu' | 'MenuItem' | 'MenuSeparator'>;
+export type ComponentSFCTableCellProjection = {
+    kind: 'default';
+} | {
+    kind: 'component';
+    identity: string | null;
+    syntax: 'cell' | 'direct';
+    bindings: ComponentSFCTableCellBindingProjection[];
+} | {
+    kind: 'tag';
+    tag: ComponentSFCTableVisualCellTag;
+    syntax: 'cell' | 'direct';
+    bindings: ComponentSFCTableCellBindingProjection[];
+} | {
+    kind: 'source';
+};
+/** Registry context required to resolve direct user component tags while reading Source. */
+export interface ComponentSFCVisualInspectionOptions {
+    resolveComponentTag?: (tag: string) => string | null;
+    resolveTypeDefinition?: (identity: string) => TypeSourceDefinition | null;
+}
+/** Visual read-model одной прямой Column внутри корневого Table. */
+export interface ComponentSFCTableColumnProjection {
+    id: string;
+    index: number;
+    key: ComponentSFCVisualSourceValue | null;
+    title: ComponentSFCVisualSourceValue | null;
+    width: ComponentSFCVisualSourceValue | null;
+    sortable: ComponentSFCVisualSourceValue | null;
+    sort: ComponentSFCVisualSourceValue | null;
+    sortBy: ComponentSFCVisualSourceValue | null;
+    pinnable: ComponentSFCVisualSourceValue | null;
+    attributes: ComponentSFCVisualAttribute[];
+    cell: ComponentSFCTableCellProjection;
+    hasCustomCell: boolean;
+    cellSource: string | null;
+    sourceRange: RComponentSFC_SourceRange;
+}
+/** Минимальные source-preserving операции visual editor таблицы. */
+export type ComponentSFCTableSourcePatch = {
+    type: 'add-column';
+    title?: string;
+    key?: string;
+} | {
+    type: 'remove-column';
+    columnIndex: number;
+} | {
+    type: 'move-column';
+    fromIndex: number;
+    toIndex: number;
+} | {
+    type: 'set-column-attribute';
+    columnIndex: number;
+    name: 'key' | 'title' | 'width' | 'sortable' | 'sort' | 'sort-by';
+    value: string | null;
+} | {
+    type: 'set-table-attribute';
+    name: 'ref' | 'selection-mode' | 'paging' | 'page-size' | 'page-sizes' | 'default-pin' | 'default-sort' | 'default-hidden';
+    value: string | null;
+} | {
+    type: 'set-column-component';
+    columnIndex: number;
+    identity: string | null;
+    syntax?: 'cell' | 'direct';
+} | {
+    type: 'set-column-tag';
+    columnIndex: number;
+    tag: ComponentSFCTableVisualCellTag | null;
+    syntax?: 'cell' | 'direct';
+} | {
+    type: 'set-column-cell-attribute';
+    columnIndex: number;
+    name: string;
+    value: string | null;
+    valueKind: 'expression' | 'literal';
+};
+/** Результат точечного изменения SFC Table source. */
+export interface ComponentSFCTableSourcePatchResult {
+    ok: boolean;
+    source: string;
+    changed: boolean;
+    projection: ComponentSFCTableVisualProjection | null;
+    diagnostics: RComponentDiagnostic[];
+    message?: string;
+}
+/** Visual read-model SFC, template которого содержит один корневой Table. */
+export interface ComponentSFCTableVisualProjection {
+    kind: 'table';
+    ref: ComponentSFCVisualSourceValue | null;
+    selectionMode: ComponentSFCVisualSourceValue | null;
+    rows: ComponentSFCVisualSourceValue | null;
+    rowKey: ComponentSFCVisualSourceValue | null;
+    paging: ComponentSFCVisualSourceValue | null;
+    pageSize: ComponentSFCVisualSourceValue | null;
+    pageSizes: ComponentSFCVisualSourceValue | null;
+    sortMode: ComponentSFCVisualSourceValue | null;
+    defaultSort: ComponentSFCVisualSourceValue | null;
+    columnPin: ComponentSFCVisualSourceValue | null;
+    defaultPin: ComponentSFCVisualSourceValue | null;
+    defaultHidden: ComponentSFCVisualSourceValue | null;
+    columnMenu: ComponentSFCVisualSourceValue | null;
+    attributes: ComponentSFCVisualAttribute[];
+    columns: ComponentSFCTableColumnProjection[];
+    sourceRange: RComponentSFC_SourceRange;
+}
+/** Результат выбора специализированного visual editor для SFC source. */
+export interface ComponentSFCVisualInspection {
+    support: {
+        kind: 'table';
+    } | {
+        kind: 'none';
+        reason: 'source-empty' | 'template-missing' | 'root-count' | 'root-not-table';
+    };
+    projection: ComponentSFCTableVisualProjection | null;
+    diagnostics: RComponentDiagnostic[];
+}