@pgcorp/ui-kit 0.9.0 → 0.10.1

package/src/components/shared/data-display/SCodeBlock.vue

@@ -1,276 +0,0 @@
-<template>
-  <div
-    v-bind="ownedAttrs.bindings()"
-    class="s-code-block"
-    :class="{
-      's-code-block--radius-none': validatedSurfaceRadius === 'none',
-      's-code-block--radius-xl': validatedSurfaceRadius === 'xl',
-      's-code-block--interactive': validatedPresentation === 'editor' && !validatedReadOnly,
-      's-code-block--viewport': !['content', 'document'].includes(validatedViewport),
-    }"
-    :data-presentation="validatedPresentation"
-  >
-    <div v-if="validatedShowHeader" class="s-code-block-header">
-      <div class="s-code-block-info">
-        <span v-if="validatedLanguage.mode === 'detect'" class="s-code-block-filename">{{ validatedLanguage.filePath }}</span>
-        <span class="s-code-block-language">{{ resolvedLanguageId }}</span>
-      </div>
-      <div class="s-code-block-actions">
-        <SButton
-          appearance="text"
-          severity="secondary"
-          size="xs"
-          :leading-icon="Copy"
-          icon-only
-          title="Копировать код"
-          aria-label="Копировать код"
-          label=""
-          @click="copyCode"
-        />
-      </div>
-    </div>
-    <div class="s-code-block-editor-region">
-      <AsyncSCodeEditor
-        v-if="validatedPresentation === 'editor'"
-        ref="codeEditor"
-        :model-value="props.code"
-        :language="validatedLanguage"
-        :capabilities="editorCapabilities"
-        :read-only="validatedReadOnly"
-        :viewport="validatedViewport"
-        v-bind="editorAccessibleName"
-        :placeholder="props.placeholder"
-        :next-selection-pos="props.nextSelectionPos"
-        @update:model-value="emit('update:code', $event)"
-        @cursor-activity="emitCursorActivity"
-        @selection-applied="emit('selection-applied', $event)"
-        @ready="onReady"
-      />
-      <pre
-        v-else
-        :ref="setPlainSurface"
-        class="s-code-block-plain"
-        :data-viewport="validatedViewport"
-        :data-line-numbers="validatedShowLineNumbers ? 'visible' : 'hidden'"
-        :aria-label="props.ariaLabel"
-        :aria-labelledby="props.ariaLabelledby"
-        :style="{ tabSize: validatedTabSize }"
-        tabindex="0"
-      ><code v-if="!validatedShowLineNumbers">{{ validatedCode }}</code><code v-else class="s-code-block-plain__lines"><span
-          v-for="(line, index) in plainLines"
-          :key="index"
-          class="s-code-block-plain__line"
-        ><span class="s-code-block-plain__line-number" aria-hidden="true">{{ index + 1 }}</span><span class="s-code-block-plain__line-content">{{ line || '\u200b' }}</span></span></code></pre>
-    </div>
-    <SAsyncState
-      v-if="validatedErrorMessage !== undefined || (validatedPresentation === 'editor' && !isReady)"
-      :state="validatedErrorMessage === undefined
-        ? { status: 'loading', message: 'Загрузка кода...' }
-        : { status: 'error', message: validatedErrorMessage }"
-      presentation="overlay"
-    />
-  </div>
-</template>
-
-<script setup lang="ts">
-import { computed, defineAsyncComponent, onMounted, ref, watch, type ComponentPublicInstance } from 'vue';
-import { useOwnedAttrs } from '../../../internal/ownedAttrs';
-import { validateBoolean, validateBoundedInteger, validateExactString, validateNonEmptyString } from '../../../internal/runtimeContract';
-import { validateCodeEditorLanguage, validateCodeEditorViewport } from '../../../internal/codeEditorContract';
-import { resolveCodeLanguageKey } from '../../../internal/codeLanguageIdentity';
-import { useNotifier } from '../../../composables/useNotifier';
-import { useClipboard } from '../../../composables/useClipboard';
-import SButton from '../controls/SButton.vue';
-import type {
-  SCodeEditorCapabilities,
-  SCodeEditorCursorActivity,
-  SCodeEditorLanguage,
-  SCodeEditorReadyPayload,
-  SCodeEditorSelectionAppliedPayload,
-  SCodeEditorViewport,
-} from './SCodeEditor.vue';
-import { Copy } from '../../icons/sputnigUiIcons';
-import SAsyncState from '../feedback/SAsyncState.vue';
-
-defineOptions({ inheritAttrs: false });
-
-type AccessibleName =
-  | { ariaLabel: string; ariaLabelledby?: never }
-  | { ariaLabel?: never; ariaLabelledby: string };
-
-/** Public adapter contract над canonical SCodeEditor leaf. / Public adapter contract over the canonical SCodeEditor leaf. */
-export type Props = AccessibleName & {
-  code: string;
-  language: SCodeEditorLanguage;
-  presentation?: 'editor' | 'plain';
-  showHeader?: boolean;
-  showLineNumbers?: boolean;
-  readOnly?: boolean;
-  interceptKeys?: (e: KeyboardEvent) => boolean;
-  tabSize?: number;
-  tabKeyBehavior?: SCodeEditorCapabilities['indentation']['keyBehavior'];
-  nextSelectionPos?: number | null;
-  surfaceRadius?: 'default' | 'none' | 'xl';
-  viewport?: SCodeEditorViewport;
-  placeholder?: string;
-  errorMessage?: string;
-};
-
-const props = withDefaults(defineProps<Props>(), {
-  presentation: 'editor',
-  showHeader: true,
-  showLineNumbers: true,
-  readOnly: true,
-  interceptKeys: undefined,
-  tabSize: 2,
-  tabKeyBehavior: 'focus-next',
-  nextSelectionPos: null,
-  surfaceRadius: 'default',
-  viewport: 'content',
-  placeholder: undefined,
-  errorMessage: undefined,
-});
-
-const isReady = ref(false);
-const codeEditor = ref<InstanceType<typeof import('./SCodeEditor.vue')['default']> | null>(null);
-const plainSurface = ref<HTMLElement | null>(null);
-const AsyncSCodeEditor = defineAsyncComponent(() => import('../../../internal/lazyCodeEditor'));
-const ownedAttrs = useOwnedAttrs({ component: 'SCodeBlock', owner: 'code block root' });
-const editorAccessibleName = computed<AccessibleName>(() => props.ariaLabel !== undefined
-  ? { ariaLabel: props.ariaLabel }
-  : { ariaLabelledby: props.ariaLabelledby });
-const emit = defineEmits<{
-  (e: 'cursor-activity', payload: { pos: number; lineFrom: number; lineTo: number; lineText: string; cursorCol: number }): void
-  (e: 'update:code', value: string): void
-  (e: 'selection-applied', payload: SCodeEditorSelectionAppliedPayload): void
-  (e: 'ready', payload: SCodeEditorReadyPayload): void
-}>();
-
-const validatedShowHeader = computed(() => validateBoolean('SCodeBlock', 'showHeader', props.showHeader));
-const validatedShowLineNumbers = computed(() => validateBoolean('SCodeBlock', 'showLineNumbers', props.showLineNumbers));
-const validatedReadOnly = computed(() => validateBoolean('SCodeBlock', 'readOnly', props.readOnly));
-const validatedPresentation = computed(() => validateExactString(
-  'SCodeBlock', 'presentation', props.presentation, ['editor', 'plain'] as const,
-));
-const validatedSurfaceRadius = computed(() => validateExactString(
-  'SCodeBlock', 'surfaceRadius', props.surfaceRadius, ['default', 'none', 'xl'] as const,
-));
-const validatedViewport = computed(() => validateCodeEditorViewport('SCodeBlock', props.viewport));
-const validatedLanguage = computed(() => validateCodeEditorLanguage('SCodeBlock', props.language));
-const validatedCode = computed(() => {
-  if (typeof props.code !== 'string') throw new TypeError('SCodeBlock: code должен быть string. / SCodeBlock: code must be a string.');
-  return props.code;
-});
-const validatedTabSize = computed(() => validateBoundedInteger('SCodeBlock', 'tabSize', props.tabSize, { minimum: 1, maximum: 16 }));
-const resolvedLanguageId = computed(() => resolveCodeLanguageKey(validatedLanguage.value));
-const plainLines = computed(() => validatedCode.value.split('\n'));
-const validatedErrorMessage = computed(() => props.errorMessage === undefined
-  ? undefined
-  : validateNonEmptyString('SCodeBlock', 'errorMessage', props.errorMessage));
-const editorCapabilities = computed<SCodeEditorCapabilities>(() => ({
-  lineNumbers: validatedShowLineNumbers.value,
-  indentation: { tabSize: validatedTabSize.value, keyBehavior: props.tabKeyBehavior },
-  ...(props.interceptKeys === undefined ? {} : { keyInterceptor: props.interceptKeys }),
-  cursorActivity: 'always',
-}));
-
-const emitCursorActivity = (payload: SCodeEditorCursorActivity) => emit('cursor-activity', {
-  pos: payload.pos,
-  lineFrom: payload.lineFrom,
-  lineTo: payload.lineTo,
-  lineText: payload.lineText,
-  cursorCol: payload.pos - payload.lineFrom,
-});
-
-const onReady = (payload: SCodeEditorReadyPayload): void => {
-  isReady.value = true;
-  emit('ready', payload);
-};
-
-let mounted = false;
-const emitPlainReady = (): void => {
-  isReady.value = true;
-  emit('ready', {
-    documentLength: validatedCode.value.length,
-    viewport: validatedViewport.value,
-    variant: 'code',
-    locked: true,
-  });
-};
-
-const syncPresentation = (): void => {
-  if (!mounted) return;
-  if (validatedPresentation.value === 'plain') emitPlainReady();
-  else isReady.value = false;
-};
-
-onMounted(() => {
-  mounted = true;
-  syncPresentation();
-});
-watch(validatedPresentation, syncPresentation);
-
-watch(
-  [validatedPresentation, validatedReadOnly],
-  ([presentation, readOnly]) => {
-    if (presentation === 'plain' && !readOnly) {
-      throw new TypeError('SCodeBlock: presentation="plain" поддерживает только readOnly=true. / SCodeBlock: presentation="plain" supports readOnly=true only.');
-    }
-    if (presentation === 'plain' && props.interceptKeys !== undefined) {
-      throw new TypeError('SCodeBlock: presentation="plain" не принимает interceptKeys. / SCodeBlock: presentation="plain" does not accept interceptKeys.');
-    }
-    if (presentation === 'plain' && props.nextSelectionPos !== null) {
-      throw new TypeError('SCodeBlock: presentation="plain" не принимает nextSelectionPos. / SCodeBlock: presentation="plain" does not accept nextSelectionPos.');
-    }
-  },
-  { immediate: true },
-);
-
-const setPlainSurface = (element: Element | ComponentPublicInstance | null): void => {
-  if (element !== null && !(element instanceof HTMLElement)) {
-    throw new TypeError('SCodeBlock: plain surface ref должен быть HTMLElement. / SCodeBlock: plain surface ref must be an HTMLElement.');
-  }
-  plainSurface.value = element;
-};
-
-const applySelection = (position: number): void => {
-  if (validatedPresentation.value === 'plain') {
-    throw new Error('SCodeBlock: applySelection недоступен в presentation="plain". / SCodeBlock: applySelection is unavailable in presentation="plain".');
-  }
-  const editor = codeEditor.value;
-  if (!editor) throw new Error('SCodeBlock: editor не готов; дождитесь ready. / SCodeBlock: editor is not ready; wait for ready.');
-  editor.applySelection(position);
-};
-
-const focus = (): void => {
-  if (validatedPresentation.value === 'plain') {
-    const surface = plainSurface.value;
-    if (!surface) throw new Error('SCodeBlock: plain surface не готов; дождитесь ready. / SCodeBlock: plain surface is not ready; wait for ready.');
-    surface.focus();
-    return;
-  }
-  const editor = codeEditor.value;
-  if (!editor) throw new Error('SCodeBlock: editor не готов; дождитесь ready. / SCodeBlock: editor is not ready; wait for ready.');
-  editor.focus();
-};
-
-defineExpose({ applySelection, focus });
-const notifier = useNotifier();
-const { copyText } = useClipboard();
-const copyCode = async () => {
-  const result = await copyText(props.code);
-  if (result.status === 'copied') {
-    notifier.success({ message: 'Код скопирован' });
-    return;
-  }
-  notifier.danger({
-    message: result.status === 'unavailable'
-      ? 'Копирование недоступно в этом браузере'
-      : result.status === 'empty'
-        ? 'Нет кода для копирования'
-        : `Ошибка копирования. ${result.error.message}`,
-  });
-};
-</script>
-
-<style lang="postcss" src="./SCodeBlock.css" scoped></style>

package/src/components/shared/data-display/SCodeEditor.vue

@@ -1,288 +0,0 @@
-<template>
-  <Codemirror
-    v-bind="ownedAttrs.bindings()"
-    class="s-code-editor"
-    :data-variant="validatedVariant"
-    :data-viewport="validatedViewport"
-    :data-line-numbers="resolvedCapabilities.lineNumbers ? 'visible' : 'hidden'"
-    :model-value="validatedModelValue"
-    :autofocus="validatedAutofocus"
-    :indent-with-tab="resolvedCapabilities.indentation.keyBehavior === 'indent'"
-    :tab-size="resolvedCapabilities.indentation.tabSize"
-    :extensions="resolvedExtensions"
-    @ready="onReady"
-    @update:model-value="onUpdate"
-  />
-</template>
-
-<script setup lang="ts">
-import { computed, ref, watch } from 'vue'
-import { Codemirror } from 'vue-codemirror'
-import { oneDark } from '@codemirror/theme-one-dark'
-import { EditorSelection, EditorState, type Extension } from '@codemirror/state'
-import { EditorView, lineNumbers, placeholder as codeMirrorPlaceholder } from '@codemirror/view'
-import { useOwnedAttrs } from '../../../internal/ownedAttrs'
-import { useInteractiveLeafRegistration } from '../../../internal/passiveContentContract'
-import { useRuntimeTheme } from '../../../internal/runtimeTheme'
-import {
-  validateBoolean,
-  validateBoundedInteger,
-  validateDomId,
-  validateNonEmptyString,
-} from '../../../internal/runtimeContract'
-import { useTrustedCodeEditorExtensions } from '../../../internal/codeEditorExtensions'
-import {
-  CODE_EDITOR_VARIANTS,
-  CODE_EDITOR_VIEWPORTS,
-  type CodeEditorCapabilitiesContract,
-  type CodeEditorLanguageContract,
-  validateCodeEditorCapabilities,
-  validateCodeEditorLanguage,
-  validateCodeEditorVariant,
-  validateCodeEditorViewport,
-} from '../../../internal/codeEditorContract'
-import { getCodeMirrorLanguageExtension, resolveCodeLanguageKey } from '../codeLanguages'
-
-defineOptions({ inheritAttrs: false })
-
-export type SCodeEditorViewport = typeof CODE_EDITOR_VIEWPORTS[number]
-export type SCodeEditorVariant = typeof CODE_EDITOR_VARIANTS[number]
-/** Явный язык либо детектирование из обязательного filePath. / Explicit language or detection from a required filePath. */
-export type SCodeEditorLanguage = CodeEditorLanguageContract
-/** Явные возможности leaf-редактора. / Explicit capabilities of the leaf editor. */
-export type SCodeEditorCapabilities = CodeEditorCapabilitiesContract
-
-/** Exact-координаты документа для cursor activity. / Exact document coordinates emitted for cursor activity. */
-export interface SCodeEditorCursorActivity {
-  pos: number
-  line: number
-  column: number
-  lineFrom: number
-  lineTo: number
-  lineText: string
-}
-
-/** Public readiness snapshot без раскрытия third-party EditorView. / Public readiness snapshot without exposing the third-party EditorView instance. */
-export interface SCodeEditorReadyPayload {
-  documentLength: number
-  viewport: SCodeEditorViewport
-  variant: SCodeEditorVariant
-  locked: boolean
-}
-
-/** Подтверждённое применение selection и источник вызова. / Confirmed selection application and its initiating API. */
-export interface SCodeEditorSelectionAppliedPayload {
-  position: number
-  source: 'controlled' | 'imperative'
-}
-
-type AccessibleName =
-  | { ariaLabel: string; ariaLabelledby?: never }
-  | { ariaLabel?: never; ariaLabelledby: string }
-
-/** Public SCodeEditor contract; размер задаёт только semantic viewport. / Public SCodeEditor contract; sizing is expressed only by semantic viewport. */
-export type Props = AccessibleName & {
-  modelValue: string
-  language: SCodeEditorLanguage
-  capabilities: SCodeEditorCapabilities
-  readOnly?: boolean
-  disabled?: boolean
-  autofocus?: boolean
-  placeholder?: string
-  viewport?: SCodeEditorViewport
-  variant?: SCodeEditorVariant
-  nextSelectionPos?: number | null
-  /** DOM id supplemental status/diagnostic owner. / DOM id of a supplemental status/diagnostic owner. */
-  ariaDescribedby?: string
-  /** Помечает editor content невалидным без владения presentation диагностики. / Marks the editor content as invalid without owning diagnostic presentation. */
-  invalid?: boolean
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  readOnly: false,
-  disabled: false,
-  autofocus: false,
-  placeholder: undefined,
-  viewport: 'content',
-  variant: 'code',
-  nextSelectionPos: null,
-  ariaDescribedby: undefined,
-  invalid: false,
-})
-
-const emit = defineEmits<{
-  'update:modelValue': [value: string]
-  'cursor-activity': [payload: SCodeEditorCursorActivity]
-  'selection-applied': [payload: SCodeEditorSelectionAppliedPayload]
-  ready: [payload: SCodeEditorReadyPayload]
-}>()
-
-const ownedAttrs = useOwnedAttrs({ component: 'SCodeEditor', owner: 'CodeMirror root adapter' })
-useInteractiveLeafRegistration({ owner: 'SCodeEditor' })
-
-const runtimeTheme = useRuntimeTheme()
-const trustedChannel = useTrustedCodeEditorExtensions()
-const editorView = ref<EditorView | null>(null)
-const pendingControlledSelection = ref<number | null>(null)
-
-const validatedModelValue = computed(() => {
-  if (typeof props.modelValue === 'string') return props.modelValue
-  throw new TypeError('SCodeEditor: modelValue должен быть строкой. / SCodeEditor: modelValue must be a string.')
-})
-
-const validatedViewport = computed<SCodeEditorViewport>(() => validateCodeEditorViewport('SCodeEditor', props.viewport))
-const validatedVariant = computed<SCodeEditorVariant>(() => validateCodeEditorVariant('SCodeEditor', props.variant))
-const validatedAutofocus = computed(() => validateBoolean('SCodeEditor', 'autofocus', props.autofocus))
-const validatedReadOnly = computed(() => validateBoolean('SCodeEditor', 'readOnly', props.readOnly))
-const validatedDisabled = computed(() => validateBoolean('SCodeEditor', 'disabled', props.disabled))
-const validatedInvalid = computed(() => validateBoolean('SCodeEditor', 'invalid', props.invalid))
-const isLocked = computed(() => validatedReadOnly.value || validatedDisabled.value)
-
-const resolvedLanguage = computed((): SCodeEditorLanguage => {
-  const language = validateCodeEditorLanguage('SCodeEditor', props.language)
-  const extension = getCodeMirrorLanguageExtension(language)
-  const languageKey = resolveCodeLanguageKey(language)
-  if (!extension && languageKey !== 'plaintext' && languageKey !== 'text') {
-    const coordinate = language.mode === 'explicit'
-      ? `language.id ${JSON.stringify(language.id)}`
-      : `language.filePath ${JSON.stringify(language.filePath)}`
-    throw new RangeError(`SCodeEditor: ${coordinate} не поддерживается. / SCodeEditor: ${coordinate} is not supported.`)
-  }
-  return language
-})
-
-const resolvedCapabilities = computed((): SCodeEditorCapabilities =>
-  validateCodeEditorCapabilities('SCodeEditor', props.capabilities))
-
-const contentAttributes = computed((): Record<string, string> => {
-  if (props.ariaLabel !== undefined && props.ariaLabelledby !== undefined) {
-    throw new TypeError('SCodeEditor: задайте только ariaLabel или ariaLabelledby. / SCodeEditor: provide only ariaLabel or ariaLabelledby.')
-  }
-  const attributes: Record<string, string> = {}
-  if (props.ariaLabel !== undefined) {
-    attributes['aria-label'] = validateNonEmptyString('SCodeEditor', 'ariaLabel', props.ariaLabel)
-  } else if (props.ariaLabelledby !== undefined) {
-    attributes['aria-labelledby'] = validateDomId('SCodeEditor', 'ariaLabelledby', props.ariaLabelledby)
-  } else {
-    throw new TypeError('SCodeEditor: требуется ariaLabel или ariaLabelledby. / SCodeEditor: ariaLabel or ariaLabelledby is required.')
-  }
-  if (props.ariaDescribedby !== undefined) {
-    attributes['aria-describedby'] = validateDomId('SCodeEditor', 'ariaDescribedby', props.ariaDescribedby)
-  }
-  if (validatedInvalid.value) attributes['aria-invalid'] = 'true'
-  if (validatedReadOnly.value) attributes['aria-readonly'] = 'true'
-  if (validatedDisabled.value) attributes['aria-disabled'] = 'true'
-  return attributes
-})
-
-const resolvedExtensions = computed<Extension[]>(() => {
-  const capabilities = resolvedCapabilities.value
-  const language = resolvedLanguage.value
-  const result: Extension[] = [...(trustedChannel?.extensions.value ?? [])]
-  if (validatedViewport.value === 'document') {
-    result.push(EditorView.theme({
-      '&.cm-editor': {
-        height: 'auto',
-        maxHeight: 'none',
-        overflow: 'visible',
-      },
-      '.cm-scroller': {
-        height: 'auto',
-        overflow: 'visible',
-      },
-    }))
-    result.push(EditorView.lineWrapping)
-  }
-  const languageExtension = getCodeMirrorLanguageExtension(language)
-  if (languageExtension) result.push(languageExtension)
-  if (runtimeTheme.value.mode === 'dark') result.push(oneDark)
-  if (capabilities.lineNumbers) result.push(lineNumbers())
-  if (props.placeholder !== undefined) result.push(codeMirrorPlaceholder(validateNonEmptyString('SCodeEditor', 'placeholder', props.placeholder)))
-  result.push(EditorState.readOnly.of(isLocked.value))
-  result.push(EditorView.editable.of(!isLocked.value))
-  result.push(EditorView.contentAttributes.of(contentAttributes.value))
-  if (capabilities.keyInterceptor && !isLocked.value) {
-    result.push(EditorView.domEventHandlers({ keydown: (event) => {
-      const handled = capabilities.keyInterceptor?.(event)
-      if (!validateBoolean('SCodeEditor', 'capabilities.keyInterceptor return value', handled)) return false
-      event.preventDefault()
-      return true
-    } }))
-  }
-  result.push(EditorView.updateListener.of((update) => {
-    editorView.value = update.view
-    if ((isLocked.value && capabilities.cursorActivity !== 'always') || (!update.selectionSet && !update.docChanged)) return
-    const pos = update.state.selection.main.head
-    const line = update.state.doc.lineAt(pos)
-    emit('cursor-activity', {
-      pos,
-      line: line.number,
-      column: pos - line.from + 1,
-      lineFrom: line.from,
-      lineTo: line.to,
-      lineText: update.state.doc.sliceString(line.from, line.to),
-    })
-  }))
-  return result
-})
-
-const validateSelectionPosition = (position: unknown, documentLength: number, coordinate: string): number =>
-  validateBoundedInteger('SCodeEditor', coordinate, position, { minimum: 0, maximum: documentLength })
-
-const dispatchSelection = (position: number, source: SCodeEditorSelectionAppliedPayload['source']): void => {
-  const view = editorView.value
-  if (!view) throw new Error('SCodeEditor: editor не готов; дождитесь ready. / SCodeEditor: editor is not ready; wait for ready.')
-  const validated = validateSelectionPosition(position, view.state.doc.length, `${source} selection position`)
-  view.dispatch({ selection: EditorSelection.single(validated), scrollIntoView: true })
-  view.focus()
-  emit('selection-applied', { position: validated, source })
-}
-
-const onUpdate = (value: string): void => {
-  if (typeof value !== 'string') {
-    throw new TypeError('SCodeEditor: CodeMirror update payload должен быть строкой. / SCodeEditor: CodeMirror update payload must be a string.')
-  }
-  if (!isLocked.value) emit('update:modelValue', value)
-}
-
-const onReady = (payload: unknown): void => {
-  if (typeof payload !== 'object' || payload === null || !('view' in payload) || !((payload as { view?: unknown }).view instanceof EditorView)) {
-    throw new TypeError('SCodeEditor: CodeMirror ready payload должен содержать EditorView. / SCodeEditor: CodeMirror ready payload must contain EditorView.')
-  }
-  editorView.value = (payload as { view: EditorView }).view
-  const readyPayload: SCodeEditorReadyPayload = {
-    documentLength: editorView.value.state.doc.length,
-    viewport: validatedViewport.value,
-    variant: validatedVariant.value,
-    locked: isLocked.value,
-  }
-  emit('ready', readyPayload)
-  if (pendingControlledSelection.value !== null) {
-    const position = pendingControlledSelection.value
-    pendingControlledSelection.value = null
-    dispatchSelection(position, 'controlled')
-  }
-}
-
-watch(() => props.nextSelectionPos, (position) => {
-  if (position === null || position === undefined) return
-  if (!Number.isInteger(position)) {
-    throw new TypeError(`SCodeEditor: nextSelectionPos должен быть целым числом; получено ${String(position)}. / SCodeEditor: nextSelectionPos must be an integer; received ${String(position)}.`)
-  }
-  if (!editorView.value) {
-    pendingControlledSelection.value = position
-    return
-  }
-  dispatchSelection(position, 'controlled')
-}, { immediate: true })
-
-defineExpose({
-  applySelection: (position: number) => dispatchSelection(position, 'imperative'),
-  focus: () => {
-    if (!editorView.value) throw new Error('SCodeEditor: editor не готов; дождитесь ready. / SCodeEditor: editor is not ready; wait for ready.')
-    editorView.value.focus()
-  },
-})
-</script>
-
-<style lang="postcss" src="./SCodeEditor.css" scoped></style>