@pgcorp/ui-kit 0.10.0 → 0.10.2

package/src/internal/codeEditorContract.ts

@@ -1,110 +0,0 @@
-import {
-  validateBoolean,
-  validateBoundedInteger,
-  validateExactString,
-  validateNonEmptyString,
-} from './runtimeContract'
-
-export const CODE_EDITOR_VIEWPORTS = ['content', 'document', 'compact', 'standard', 'expanded', 'fill'] as const
-export const CODE_EDITOR_VARIANTS = ['code', 'sql'] as const
-export const CODE_EDITOR_KEY_BEHAVIORS = ['indent', 'focus-next'] as const
-export const CODE_EDITOR_CURSOR_ACTIVITY_MODES = ['editable', 'always'] as const
-
-/**
- * Язык задаётся явно либо определяется только из обязательного пути файла.
- * Language is either explicit or detected exclusively from a required file path.
- */
-export type CodeEditorLanguageContract =
-  | { mode: 'explicit'; id: string; filePath?: never }
-  | { mode: 'detect'; filePath: string; id?: never }
-
-/** Явные CodeMirror-возможности без вывода опций из presentation. / Explicit CodeMirror capabilities; no option is inferred from presentation. */
-export interface CodeEditorCapabilitiesContract {
-  lineNumbers: boolean
-  indentation: {
-    tabSize: number
-    keyBehavior: typeof CODE_EDITOR_KEY_BEHAVIORS[number]
-  }
-  keyInterceptor?: (event: KeyboardEvent) => boolean
-  cursorActivity: typeof CODE_EDITOR_CURSOR_ACTIVITY_MODES[number]
-}
-
-function isCodeEditorKeyInterceptor(value: unknown): value is (event: KeyboardEvent) => boolean {
-  return typeof value === 'function'
-}
-
-function assertPlainExactRecord(
-  owner: string,
-  coordinate: string,
-  value: unknown,
-  allowed: readonly string[],
-): Record<string, unknown> {
-  if (typeof value !== 'object' || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype) {
-    throw new TypeError(`${owner}: ${coordinate} должен быть plain object. / ${owner}: ${coordinate} must be a plain object.`)
-  }
-  const record = value as Record<string, unknown>
-  const unexpected = Object.keys(record).filter((key) => !allowed.includes(key))
-  if (unexpected.length > 0) {
-    throw new TypeError(`${owner}.${coordinate}: неизвестные поля ${unexpected.map((key) => JSON.stringify(key)).join(', ')}. / ${owner}.${coordinate}: unknown fields ${unexpected.map((key) => JSON.stringify(key)).join(', ')}.`)
-  }
-  return record
-}
-
-export function validateCodeEditorLanguage(
-  owner: string,
-  value: unknown,
-): CodeEditorLanguageContract {
-  const record = assertPlainExactRecord(owner, 'language', value, ['mode', 'id', 'filePath'])
-  const mode = validateExactString(owner, 'language.mode', record.mode, ['explicit', 'detect'] as const)
-  const allowedFields = mode === 'explicit' ? ['mode', 'id'] : ['mode', 'filePath']
-  const unexpected = Object.keys(record).filter((key) => !allowedFields.includes(key))
-  if (unexpected.length > 0) {
-    throw new TypeError(
-      `${owner}.language: неизвестные поля ${unexpected.map((key) => JSON.stringify(key)).join(', ')}. `
-      + `/ ${owner}.language: unknown fields ${unexpected.map((key) => JSON.stringify(key)).join(', ')}.`,
-    )
-  }
-  if (mode === 'explicit') {
-    return { mode, id: validateNonEmptyString(owner, 'language.id', record.id) }
-  }
-  return { mode, filePath: validateNonEmptyString(owner, 'language.filePath', record.filePath) }
-}
-
-export function validateCodeEditorCapabilities(
-  owner: string,
-  value: unknown,
-): CodeEditorCapabilitiesContract {
-  const record = assertPlainExactRecord(
-    owner,
-    'capabilities',
-    value,
-    ['lineNumbers', 'indentation', 'keyInterceptor', 'cursorActivity'],
-  )
-  const indentation = assertPlainExactRecord(
-    owner,
-    'capabilities.indentation',
-    record.indentation,
-    ['tabSize', 'keyBehavior'],
-  )
-  const keyInterceptor = record.keyInterceptor
-  if (keyInterceptor !== undefined && !isCodeEditorKeyInterceptor(keyInterceptor)) {
-    throw new TypeError(`${owner}: capabilities.keyInterceptor должен быть функцией. / ${owner}: capabilities.keyInterceptor must be a function.`)
-  }
-  return {
-    lineNumbers: validateBoolean(owner, 'capabilities.lineNumbers', record.lineNumbers),
-    indentation: {
-      tabSize: validateBoundedInteger(owner, 'capabilities.indentation.tabSize', indentation.tabSize, { minimum: 1, maximum: 16 }),
-      keyBehavior: validateExactString(owner, 'capabilities.indentation.keyBehavior', indentation.keyBehavior, CODE_EDITOR_KEY_BEHAVIORS),
-    },
-    ...(keyInterceptor === undefined ? {} : { keyInterceptor }),
-    cursorActivity: validateExactString(owner, 'capabilities.cursorActivity', record.cursorActivity, CODE_EDITOR_CURSOR_ACTIVITY_MODES),
-  }
-}
-
-export function validateCodeEditorViewport(owner: string, value: unknown): typeof CODE_EDITOR_VIEWPORTS[number] {
-  return validateExactString(owner, 'viewport', value, CODE_EDITOR_VIEWPORTS)
-}
-
-export function validateCodeEditorVariant(owner: string, value: unknown): typeof CODE_EDITOR_VARIANTS[number] {
-  return validateExactString(owner, 'variant', value, CODE_EDITOR_VARIANTS)
-}

package/src/internal/codeEditorExtensions.ts

@@ -1,27 +0,0 @@
-import type { ComputedRef, InjectionKey } from 'vue'
-import { inject, provide } from 'vue'
-import type { Extension } from '@codemirror/state'
-
-export type TrustedCodeEditorExtensionOwner = 'SSqlEditor'
-
-interface TrustedCodeEditorExtensionChannel {
-  owner: TrustedCodeEditorExtensionOwner
-  extensions: ComputedRef<readonly Extension[]>
-}
-
-const TRUSTED_CODE_EDITOR_EXTENSION_KEY: InjectionKey<TrustedCodeEditorExtensionChannel> = Symbol(
-  'sputnig-ui-kit-trusted-code-editor-extensions',
-)
-
-/** Internal-only CodeMirror extension channel for audited UI-kit adapters. */
-export function provideTrustedCodeEditorExtensions(
-  owner: TrustedCodeEditorExtensionOwner,
-  extensions: ComputedRef<readonly Extension[]>,
-): void {
-  provide(TRUSTED_CODE_EDITOR_EXTENSION_KEY, { owner, extensions })
-}
-
-/** Consumes extensions supplied by the nearest audited UI-kit adapter. */
-export function useTrustedCodeEditorExtensions(): TrustedCodeEditorExtensionChannel | null {
-  return inject(TRUSTED_CODE_EDITOR_EXTENSION_KEY, null)
-}

package/src/internal/codeHighlight.ts

@@ -1,110 +0,0 @@
-import hljs from 'highlight.js/lib/core'
-import bash from 'highlight.js/lib/languages/bash'
-import dockerfile from 'highlight.js/lib/languages/dockerfile'
-import javascript from 'highlight.js/lib/languages/javascript'
-import makefile from 'highlight.js/lib/languages/makefile'
-import nginx from 'highlight.js/lib/languages/nginx'
-import powershell from 'highlight.js/lib/languages/powershell'
-import python from 'highlight.js/lib/languages/python'
-import typescript from 'highlight.js/lib/languages/typescript'
-import xml from 'highlight.js/lib/languages/xml'
-import yaml from 'highlight.js/lib/languages/yaml'
-
-import type { CodeEditorLanguageContract } from './codeEditorContract'
-import { resolveCodeLanguageKey } from './codeLanguageIdentity'
-
-export type CodeHighlightToken = string | {
-  readonly scope: string | null
-  readonly children: readonly CodeHighlightToken[]
-}
-
-const HIGHLIGHT_LANGUAGE_ALIASES: Readonly<Record<string, string>> = {
-  shell: 'bash',
-  text: 'plaintext',
-}
-
-const SAFE_SCOPE_PATTERN = /^[a-z][a-z0-9_.-]*$/u
-
-hljs.registerLanguage('bash', bash)
-hljs.registerLanguage('dockerfile', dockerfile)
-hljs.registerLanguage('javascript', javascript)
-hljs.registerLanguage('makefile', makefile)
-hljs.registerLanguage('nginx', nginx)
-hljs.registerLanguage('powershell', powershell)
-hljs.registerLanguage('python', python)
-hljs.registerLanguage('typescript', typescript)
-hljs.registerLanguage('xml', xml)
-hljs.registerLanguage('yaml', yaml)
-
-function escapeHighlightedCode(code: string): string {
-  return code
-    .replace(/&/gu, '&amp;')
-    .replace(/</gu, '&lt;')
-    .replace(/>/gu, '&gt;')
-    .replace(/"/gu, '&quot;')
-    .replace(/'/gu, '&#39;')
-}
-
-function resolveHighlightLanguage(language: CodeEditorLanguageContract): string {
-  const languageKey = resolveCodeLanguageKey(language)
-  return HIGHLIGHT_LANGUAGE_ALIASES[languageKey] ?? languageKey
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-function readTokenNode(value: unknown, coordinate: string): CodeHighlightToken {
-  if (typeof value === 'string') return value
-  if (!isRecord(value)) throw new TypeError(`codeHighlight: ${coordinate} must be a token node or string.`)
-  const unexpected = Object.keys(value).filter((key) => !['scope', 'children', 'language'].includes(key))
-  if (unexpected.length > 0) {
-    throw new TypeError(`codeHighlight: ${coordinate} contains unknown fields ${unexpected.join(', ')}.`)
-  }
-  const rawScope = value.scope
-  if (rawScope !== undefined && (typeof rawScope !== 'string' || !SAFE_SCOPE_PATTERN.test(rawScope))) {
-    throw new TypeError(`codeHighlight: ${coordinate}.scope is invalid.`)
-  }
-  if (!Array.isArray(value.children)) {
-    throw new TypeError(`codeHighlight: ${coordinate}.children must be an array.`)
-  }
-  return Object.freeze({
-    scope: rawScope ?? null,
-    children: Object.freeze(value.children.map((child, index) => readTokenNode(child, `${coordinate}.children[${index}]`))),
-  })
-}
-
-function highlightResult(code: string, language: CodeEditorLanguageContract) {
-  const resolvedLanguage = resolveHighlightLanguage(language)
-  if (!hljs.getLanguage(resolvedLanguage)) return null
-  return hljs.highlight(code, { language: resolvedLanguage, ignoreIllegals: true })
-}
-
-export function isCodeHighlightLanguageSupported(language: CodeEditorLanguageContract): boolean {
-  return Boolean(hljs.getLanguage(resolveHighlightLanguage(language)))
-}
-
-/** Returns trusted library markup only for the legacy sanitized-document pipeline. */
-export function highlightCodeToHtml(code: string, language: CodeEditorLanguageContract): string {
-  return highlightResult(code, language)?.value ?? escapeHighlightedCode(code)
-}
-
-/** Converts the Highlight.js emitter boundary into a closed, validated token tree without HTML rendering. */
-export function highlightCodeToTokens(
-  code: string,
-  language: CodeEditorLanguageContract,
-): readonly CodeHighlightToken[] {
-  const result = highlightResult(code, language)
-  if (result === null) return Object.freeze([code])
-  const root = Reflect.get(result._emitter, 'root')
-  const validated = readTokenNode(root, 'root')
-  if (typeof validated === 'string') {
-    throw new TypeError('codeHighlight: emitter root must be a token node.')
-  }
-  return validated.children
-}
-
-export function highlightScopeClass(scope: string): string {
-  if (!SAFE_SCOPE_PATTERN.test(scope)) throw new TypeError(`codeHighlight: invalid scope ${JSON.stringify(scope)}.`)
-  return `hljs-${scope.replace(/\./gu, '_')}`
-}

package/src/internal/codeLanguageIdentity.ts

@@ -1,89 +0,0 @@
-import {
-  type CodeEditorLanguageContract,
-  validateCodeEditorLanguage,
-} from './codeEditorContract'
-
-type NullableText = string | null | undefined
-
-const SPECIAL_FILENAMES: Readonly<Record<string, string>> = {
-  'cmakelists.txt': 'cmake',
-  'dockerfile': 'dockerfile',
-  'docker-compose.yml': 'yaml',
-  'docker-compose.yaml': 'yaml',
-  'compose.yml': 'yaml',
-  'compose.yaml': 'yaml',
-  '.env': 'properties',
-  '.env.example': 'properties',
-  '.env.local': 'properties',
-  '.env.development': 'properties',
-  '.env.production': 'properties',
-  'makefile': 'makefile',
-  'nginx.conf': 'nginx',
-}
-
-const LANGUAGE_ALIASES: Readonly<Record<string, string>> = {
-  bash: 'shell',
-  'c#': 'cs',
-  csharp: 'cs',
-  env: 'properties',
-  fish: 'shell',
-  handlebars: 'handlebars',
-  htm: 'html',
-  js: 'javascript',
-  jsonc: 'json',
-  json5: 'json',
-  log: 'text',
-  make: 'makefile',
-  md: 'markdown',
-  mk: 'makefile',
-  plaintext: 'text',
-  proto3: 'proto',
-  ps1: 'powershell',
-  psm1: 'powershell',
-  psd1: 'powershell',
-  py: 'python',
-  pyw: 'python',
-  pyi: 'python',
-  rbw: 'ruby',
-  sh: 'shell',
-  shellsession: 'shell',
-  ts: 'typescript',
-  text: 'text',
-  txt: 'text',
-  yaml: 'yaml',
-  yml: 'yaml',
-  zsh: 'shell',
-}
-
-function normalizeDetectedToken(value: NullableText): string | null {
-  if (!value) return null
-  const normalized = value.trim().toLowerCase().replace(/^\./u, '')
-  return normalized ? LANGUAGE_ALIASES[normalized] ?? normalized : null
-}
-
-function resolveLanguageFromFilePath(filePath: NullableText): string | null {
-  if (!filePath) return null
-  const normalizedPath = filePath.trim().toLowerCase()
-  if (!normalizedPath) return null
-  const basename = normalizedPath.split('/').pop() ?? normalizedPath
-  const special = SPECIAL_FILENAMES[basename]
-  if (special !== undefined) return special
-  if (basename.startsWith('dockerfile.')) return 'dockerfile'
-  if (!basename.includes('.')) return null
-  return normalizeDetectedToken(basename.split('.').pop())
-}
-
-/**
- * Разрешает стабильную language identity без загрузки editor/highlighter runtime.
- * Resolves stable language identity without loading editor or highlighter runtime.
- */
-export function resolveCodeLanguageKey(input: CodeEditorLanguageContract): string {
-  const language = validateCodeEditorLanguage('codeLanguages', input)
-  if (language.mode === 'explicit') return LANGUAGE_ALIASES[language.id] ?? language.id
-  const detected = resolveLanguageFromFilePath(language.filePath)
-  if (detected !== null) return detected
-  throw new RangeError(
-    `codeLanguages: невозможно определить язык по filePath ${JSON.stringify(language.filePath)}. `
-    + `/ codeLanguages: cannot detect a language from filePath ${JSON.stringify(language.filePath)}.`,
-  )
-}