Символы в TypeScript

const sym1 = Symbol();
const sym2 = Symbol();
console.log(sym1 === sym2); // всегда false, даже если конструкторы вызваны одинаково

const uniqueKey = Symbol('description');
const obj = {
  [uniqueKey]: 'Секретное значение',
  normalKey: 'Обычное значение'
};
 
console.log(obj[uniqueKey]); // 'Секретное значение'

// Плагин A
obj.extension = { filter: (data) => data.type === 'A' };
 
// Плагин B (перезаписывает расширение от плагина A)
obj.extension = { sort: (data) => data.sort((a, b) => a.name.localeCompare(b.name)) };

// Плагин A
const extA = Symbol('extension-a');
obj[extA] = { filter: (data) => data.type === 'A' };
 
// Плагин B (использует свой собственный ключ, не конфликтует)
const extB = Symbol('extension-b');
obj[extB] = { sort: (data) => data.sort((a, b) => a.name.localeCompare(b.name)) };

// Локальный символ (всегда уникален)
const localSymbol = Symbol('myKey');
 
// Глобальный символ (доступен через реестр)
const globalSymbol = Symbol.for('myKey');
 
// Получение того же глобального символа
const sameGlobalSymbol = Symbol.for('myKey');
 
console.log(globalSymbol === sameGlobalSymbol); // true

// В ядре приложения
export const PLUGIN_INIT = Symbol.for('app.plugin.init');
export const PLUGIN_SHUTDOWN = Symbol.for('app.plugin.shutdown');
 
// В плагине
import { PLUGIN_INIT, PLUGIN_SHUTDOWN } from 'app-core';
 
class MyPlugin {
  [PLUGIN_INIT]() {
    console.log('Плагин инициализирован');
  }
  
  [PLUGIN_SHUTDOWN]() {
    console.log('Плагин остановлен');
  }
}

// Бенчмарк, который я проводил
const stringKey = 'myKey';
const symbolKey = Symbol('myKey');
const obj = {
[stringKey]: 'string value',
[symbolKey]: 'symbol value'
};
 
console.time('string access');
for (let i = 0; i < 1000000; i++) {
const val = obj[stringKey];
}
console.timeEnd('string access');
 
console.time('symbol access');
for (let i = 0; i < 1000000; i++) {
const val = obj[symbolKey];
}
console.timeEnd('symbol access');

// Делает объект итерируемым (for...of)
const myIterable = {
data: [1, 2, 3],
[Symbol.iterator]() {
  let index = 0;
  const data = this.data;
  return {
    next() {
      if (index < data.length) {
        return { value: data[index++], done: false };
      }
      return { value: undefined, done: true };
    }
  };
}
};
 
for (const item of myIterable) {
console.log(item); // 1, 2, 3
}
 
// Определяет поведение при преобразовании в примитив
const myObject = {
[Symbol.toPrimitive](hint) {
  if (hint === 'number') return 42;
  if (hint === 'string') return 'Hello';
  return true;
}
};
 
console.log(+myObject); // 42
console.log(`${myObject}`); // "Hello"
console.log(myObject + ''); // "true"

const privateProperty = Symbol('private');
const obj = {
regular: 'Я видим всем',
[privateProperty]: 'Меня сложно найти'
};
 
console.log(Object.keys(obj)); // ['regular']
console.log(Object.getOwnPropertyNames(obj)); // ['regular']
 
// Только специальный метод видит символьные ключи
console.log(Object.getOwnPropertySymbols(obj)); // [Symbol(private)]

// Переменные с let получают тип symbol
let sym1 = Symbol('sym1');
// TypeScript выводит тип: symbol
 
// Константы получают более конкретный тип
const sym2 = Symbol('sym2');
// TypeScript выводит тип: typeof sym2 (по сути, unique symbol)

const AUTH_TOKEN = Symbol('auth');
 
function processAuth(token: typeof AUTH_TOKEN) {
  // Работаем с токеном
}
 
processAuth(AUTH_TOKEN); // Работает
processAuth(Symbol('auth')); // Ошибка! Хотя описание то же самое

// Явное объявление типа unique symbol
const MY_SPECIAL_KEY: unique symbol = Symbol('special');
 
class ApiService {
  static readonly API_VERSION: unique symbol = Symbol('version');
  
  checkVersion(version: typeof ApiService.API_VERSION) {
    // Гарантировано, что будет передан только правильный символ
  }
}

function createUniqueKey(): unique symbol {
  // Ошибка! Значение типа 'symbol' не может быть присвоено типу 'unique symbol'
  return Symbol('dynamic'); 
}

const METADATA = Symbol('metadata');
 
interface ConfigWithMetadata {
  name: string;
  [METADATA]: any; // Используем конкретный символ как ключ
}
 
const config: ConfigWithMetadata = {
  name: 'Default Config',
  [METADATA]: { version: '1.0.0' }
};
 
// Можно также определить индексные типы с символьными ключами
interface Cache {
  [key: symbol]: unknown;
}

const ORIGINAL = Symbol('original'); // typeof ORIGINAL (unique symbol)
const copy = ORIGINAL; // symbol
 
function acceptOriginal(s: typeof ORIGINAL) {}
acceptOriginal(ORIGINAL); // OK
acceptOriginal(copy); // Ошибка! Тип 'symbol' не присваиваемый к типу 'typeof ORIGINAL'

const ORIGINAL = Symbol('original');
const copy: typeof ORIGINAL = ORIGINAL; // Теперь copy имеет тип typeof ORIGINAL
 
function acceptOriginal(s: typeof ORIGINAL) {}
acceptOriginal(copy); // Теперь работает

const CLICK_EVENT = Symbol('click');
const HOVER_EVENT = Symbol('hover');
 
type ClickEvent = {
  type: typeof CLICK_EVENT;
  x: number;
  y: number;
};
 
type HoverEvent = {
  type: typeof HOVER_EVENT;
  elementId: string;
};
 
type UIEvent = ClickEvent | HoverEvent;
 
function handleEvent(event: UIEvent) {
  switch (event.type) {
    case CLICK_EVENT:
      // TypeScript знает, что это ClickEvent
      console.log(`Клик в координатах: ${event.x}, ${event.y}`);
      break;
    case HOVER_EVENT:
      // TypeScript знает, что это HoverEvent
      console.log(`Наведение на элемент: ${event.elementId}`);
      break;
  }
}

const RED = Symbol('red');
const GREEN = Symbol('green');
const BLUE = Symbol('blue');
 
type PrimaryColor = typeof RED | typeof GREEN | typeof BLUE;
 
function setPrimaryColor(color: PrimaryColor) {
  // Работаем с цветом, гарантированно получаем только разрешенные значения
}
 
setPrimaryColor(RED); // Работает
setPrimaryColor(Symbol('red')); // Ошибка! Не тот символ

const TITLE = Symbol('title');
const CONTENT = Symbol('content');
const AUTHOR = Symbol('author');
 
type DocumentFields = {
  [TITLE]: string;
  [CONTENT]: string;
  [AUTHOR]: string;
};
 
// Создаем тип с опциональными полями
type PartialDocument = {
  [K in keyof DocumentFields]?: DocumentFields[K];
};
 
// Создаем тип только для чтения
type ReadonlyDocument = {
  readonly [K in keyof DocumentFields]: DocumentFields[K];
};

const ID = Symbol('id');
const NAME = Symbol('name');
 
type HasId<T> = T extends { [ID]: unknown } ? true : false;
type HasName<T> = T extends { [NAME]: unknown } ? true : false;
 
type Entity = {
  [ID]: number;
  data: string;
};
 
type WithNameOnly = {
  [NAME]: string;
};
 
// Проверяем типы
type EntityHasId = HasId<Entity>; // true
type EntityHasName = HasName<Entity>; // false
type WithNameOnlyHasId = HasId<WithNameOnly>; // false

class NumberRange implements Iterable<number> {
  constructor(private start: number, private end: number) {}
 
  // Обратите внимание на типизацию метода
  [Symbol.iterator](): Iterator<number> {
    let current = this.start;
    const end = this.end;
    
    return {
      next(): IteratorResult<number> {
        if (current <= end) {
          return { value: current++, done: false };
        }
        return { value: undefined, done: true };
      }
    };
  }
}
 
// Теперь объект поддерживает итерацию
const range = new NumberRange(1, 5);
for (const num of range) {
  console.log(num); // 1, 2, 3, 4, 5
}

interface CustomIterator<T> extends Iterator<T> {
  reset(): void; // дополнительный метод
  next(): IteratorResult<T>;
}
 
class EnhancedCollection<T> implements Iterable<T> {
  private items: T[] = [];
 
  add(item: T): void {
    this.items.push(item);
  }
 
  [Symbol.iterator](): CustomIterator<T> {
    let index = 0;
    const items = this.items;
    
    return {
      reset() {
        index = 0;
      },
      next() {
        if (index < items.length) {
          return { value: items[index++], done: false };
        }
        return { value: undefined, done: true };
      }
    };
  }
}

class AsyncDataSource implements AsyncIterable<string> {
  private data: string[] = [];
  private isLoading = false;
 
  async loadMoreData(): Promise<string[]> {
    // Имитация загрузки данных
    this.isLoading = true;
    await new Promise(resolve => setTimeout(resolve, 500));
    const newData = [`Item ${this.data.length + 1}`, [INLINE]Item ${this.data.length + 2}[/INLINE]];
    this.data.push(...newData);
    this.isLoading = false;
    return newData;
  }
 
  [Symbol.asyncIterator](): AsyncIterator<string> {
    let index = 0;
    const self = this;
 
    return {
      async next(): Promise<IteratorResult<string>> {
        if (index >= self.data.length && !self.isLoading) {
          await self.loadMoreData();
        }
 
        if (index < self.data.length) {
          return { value: self.data[index++], done: false };
        }
        
        return { value: undefined, done: true };
      }
    };
  }
}
 
// Использование
async function processData() {
  const source = new AsyncDataSource();
  
  for await (const item of source) {
    console.log(item);
    if (item === 'Item 10') break; // Ограничиваем количество итераций
  }
}

// Создаем символьные константы
const Red = Symbol('red');
const Green = Symbol('green');
const Blue = Symbol('blue');
 
// Объединяем их в объект (как enum)
const Color = {
  Red,
  Green, 
  Blue
} as const;
 
// Создаем тип на основе значений объекта
type ColorType = typeof Color[keyof typeof Color];
 
// Теперь можно использовать в функциях
function paintElement(color: ColorType) {
  // Логика окрашивания
  if (color === Color.Red) {
    console.log('Красим в красный');
  } else if (color === Color.Green) {
    console.log('Красим в зеленый');
  } else if (color === Color.Blue) {
    console.log('Красим в синий');
  }
}
 
// Корректное использование
paintElement(Color.Red); // Работает
// Некорректное использование
// paintElement(Symbol('red')); // Ошибка компиляции

const SECRET_CONFIG = Symbol('config');
 
class Service {
  [SECRET_CONFIG] = { apiKey: '12345' };
  
  public name = 'Main Service';
}
 
const service = new Service();
 
// Обычное перечисление не покажет символьные ключи
Object.keys(service); // ['name']
 
// Нужен специальный метод для получения символьных ключей
Object.getOwnPropertySymbols(service); // [Symbol(config)]
 
// Для получения всех ключей (включая символы):
Reflect.ownKeys(service); // ['name', Symbol(config)]

function getSymbolPropOrDefault<T, K extends symbol, D>(
  obj: T,
  key: K,
  defaultValue: D
): K extends keyof T ? T[K] : D {
  return (typeof obj === 'object' && obj !== null && key in obj)
    ? (obj as any)[key]
    : defaultValue as any;
}
 
// Использование
const value = getSymbolPropOrDefault(service, SECRET_CONFIG, {});

interface StrictSymbolMap {
  // В строгом режиме обязательно указать индексную сигнатуру для символов
  [key: symbol]: string;
}
 
const map: StrictSymbolMap = {};
const key1 = Symbol('one');
const key2 = Symbol('two');
 
map[key1] = 'Value 1';
map[key2] = 'Value 2';
 
// В строгом режиме будет ошибка без явного приведения типов:
// map[key1] = 123; // Ошибка: Тип 'number' не может быть присвоен типу 'string'

// В строгом режиме нужно правильно типизировать обработчики для well-known символов
class MyClass {
  // Тип должен соответствовать спецификации
  [Symbol.toStringTag]: string = 'MyClass';
  
  // Для кастомных методов важно указывать правильные сигнатуры
  [Symbol.toPrimitive](hint: string): string | number | boolean {
    switch (hint) {
      case 'number': return 100;
      case 'string': return 'Custom string';
      default: return true;
    }
  }
}

// Символ доступен только внутри модуля
const _metadata = Symbol('metadata');
 
export class UserProfile {
  public name: string;
  public email: string;
  
  // Приватное символьное свойство
  private [_metadata]: {
    lastModified: Date;
    accessLevel: number;
    internalId: string;
  };
  
  constructor(name: string, email: string) {
    this.name = name;
    this.email = email;
    this[_metadata] = {
      lastModified: new Date(),
      accessLevel: 1,
      internalId: crypto.randomUUID()
    };
  }
  
  // Геттер для части внутренних данных
  get modificationDate(): Date {
    return this[_metadata].lastModified;
  }
  
  // Метод использующий приватные данные
  hasAccess(requiredLevel: number): boolean {
    return this[_metadata].accessLevel >= requiredLevel;
  }
}

// Без брендирования - проблема
type UserId = string;
type AccountId = string;
 
function processUser(id: UserId) { /* ... */ }
function processAccount(id: AccountId) { /* ... */ }
 
const userId: UserId = "user-123";
const accountId: AccountId = "acc-456";
 
// TypeScript не увидит ошибку! Строки структурно одинаковые
processAccount(userId); // Ой! Передали не тот ID

// Символы для брендирования
declare const UserIdBrand: unique symbol;
declare const AccountIdBrand: unique symbol;
 
// Брендированные типы
type UserId = string & { readonly [UserIdBrand]: unique symbol };
type AccountId = string & { readonly [AccountIdBrand]: unique symbol };
 
// Функции-конструкторы для безопасного создания идентификаторов
function createUserId(id: string): UserId {
  return id as UserId;
}
 
function createAccountId(id: string): AccountId {
  return id as AccountId;
}
 
// Теперь наши функции типобезопасны
function processUser(id: UserId) { /* ... */ }
function processAccount(id: AccountId) { /* ... */ }
 
const userId = createUserId("user-123");
const accountId = createAccountId("acc-456");
 
processUser(userId); // Ок
// processAccount(userId); // Ошибка компиляции!

// Проблемный подход со строками
library.registerHandler('beforeProcess', handler);
library.registerHandler('afterValidation', anotherHandler);

// Определяем публичные символы для хуков
export const Hooks = {
  BEFORE_PROCESS: Symbol('hooks:beforeProcess'),
  AFTER_VALIDATION: Symbol('hooks:afterValidation'),
  ON_ERROR: Symbol('hooks:onError'),
  COMPLETE: Symbol('hooks:complete')
} as const;
 
export type HookType = typeof Hooks[keyof typeof Hooks];
 
// Типы для хендлеров разных хуков
interface BeforeProcessData { source: string; }
interface AfterValidationData { valid: boolean; errors?: string[]; }
interface ErrorData { error: Error; phase: string; }
interface CompleteData { duration: number; recordsProcessed: number; }
 
// Маппинг типов данных для каждого хука
export interface HookDataMap {
  [Hooks.BEFORE_PROCESS]: BeforeProcessData;
  [Hooks.AFTER_VALIDATION]: AfterValidationData;
  [Hooks.ON_ERROR]: ErrorData;
  [Hooks.COMPLETE]: CompleteData;
}
 
// Теперь наше API типобезопасно
export function registerHandler<T extends HookType>(
  hook: T,
  handler: (data: HookDataMap[T]) => void
): void {
  // Реализация...
}
 
// Использование
registerHandler(Hooks.BEFORE_PROCESS, (data) => {
  // TypeScript знает, что data имеет тип BeforeProcessData
  console.log(data.source);
});

class SmartNumber {
  constructor(private value: number) {}
 
  // Определяем поведение при приведении к примитиву
  [Symbol.toPrimitive](hint: string): any {
    switch (hint) {
      case 'number':
        return this.value;
      case 'string':
        return `SmartNumber(${this.value})`;
      case 'default':
        return this.value.toString();
    }
  }
  
  // Реализуем свой итератор для перебора цифр числа
  [Symbol.iterator](): Iterator<number> {
    const digits = this.value.toString().split('').map(Number);
    let index = 0;
    
    return {
      next() {
        if (index < digits.length) {
          return { value: digits[index++], done: false };
        }
        return { value: undefined, done: true };
      }
    };
  }
}
 
const smartNum = new SmartNumber(12345);
 
// Используем в разных контекстах
const doubled = smartNum * 2; // 24690
const greeting = `Value: ${smartNum}`; // "Value: SmartNumber(12345)"
 
// Итерация по цифрам
for (const digit of smartNum) {
  console.log(digit); // Выведет 1, 2, 3, 4, 5
}

class VersionRange {
  constructor(private min: string, private max: string) {}
  
  // Кастомное поведение instanceof
  static [Symbol.hasInstance](instance: any): boolean {
    if (typeof instance !== 'string') return false;
    
    // Проверяем, соответствует ли строка формату версии
    return /^\d+\.\d+\.\d+$/.test(instance);
  }
}
 
// Теперь можем делать такие проверки
console.log('1.2.3' instanceof VersionRange); // true
console.log('1.2' instanceof VersionRange); // false
console.log(123 instanceof VersionRange); // false

const validationMetadataKey = Symbol('validation:metadata');
 
interface ValidationRule {
  property: string;
  type: 'required' | 'minLength' | 'maxLength' | 'pattern' | 'custom';
  value?: any;
  message?: string;
  validator?: (value: any) => boolean;
}
 
// Декоратор для добавления правил валидации
function Validate(rule: Omit<ValidationRule, 'property'>) {
  return function(target: any, propertyKey: string) {
    const rules: ValidationRule[] = Reflect.getMetadata(validationMetadataKey, target.constructor) || [];
    
    rules.push({
      ...rule,
      property: propertyKey
    });
    
    Reflect.defineMetadata(validationMetadataKey, rules, target.constructor);
  };
}
 
// Пример использования
class UserDTO {
  @Validate({ type: 'required', message: 'Name is required' })
  @Validate({ type: 'minLength', value: 3, message: 'Name must be at least 3 characters' })
  name!: string;
  
  @Validate({ type: 'pattern', value: /^[^\s@]+@[^\s@]+\.[^\s@]+$/, message: 'Invalid email format' })
  email!: string;
}
 
// Функция валидации
function validate<T>(instance: T): { valid: boolean, errors: string[] } {
  const errors: string[] = [];
  const constructor = instance.constructor;
  const rules: ValidationRule[] = Reflect.getMetadata(validationMetadataKey, constructor) || [];
  
  for (const rule of rules) {
    const value = (instance as any)[rule.property];
    let valid = true;
    
    switch (rule.type) {
      case 'required':
        valid = value !== undefined && value !== null && value !== '';
        break;
      case 'minLength':
        valid = value?.length >= rule.value;
        break;
      case 'pattern':
        valid = rule.value.test(value);
        break;
      case 'custom':
        valid = rule.validator!(value);
        break;
    }
    
    if (!valid && rule.message) {
      errors.push(rule.message);
    }
  }
  
  return { valid: errors.length === 0, errors };
}

// internal.ts - не экспортируется напрямую
export const InternalAPI = {
  CACHE_ACCESS: Symbol('internal:cache'),
  BYPASS_HOOKS: Symbol('internal:bypass-hooks'),
  RAW_CONNECTION: Symbol('internal:connection')
};
 
// library.ts - основной публичный API
import { InternalAPI } from './internal';
 
export class DatabaseClient {
  // Публичное API
  connect() { /* ... */ }
  query() { /* ... */ }
  
  // Внутреннее API, доступное только продвинутым пользователям,
  // которые явно импортировали InternalAPI
  [InternalAPI.CACHE_ACCESS]() {
    // Прямой доступ к кэшу запросов
  }
  
  [InternalAPI.RAW_CONNECTION]() {
    // Доступ к низкоуровневому соединению
  }
}
 
// Опционально можем экспортировать internal API отдельно
export { InternalAPI as Internal };

const USER_STATE = Symbol('userState');
const APP_SETTINGS = Symbol('appSettings');
 
const state = {
[USER_STATE]: { name: "John", permissions: ["admin"] },
[APP_SETTINGS]: { theme: "dark", notifications: true }
};
 
// При попытке сохранить...
localStorage.setItem('appState', JSON.stringify(state));
 
// ...и восстановить
const restoredState = JSON.parse(localStorage.getItem('appState') || '{}');
console.log(restoredState); // {} - пустой объект!

const symbolMap = {
[Symbol('userState').toString()]: 'USER_STATE',
[Symbol('appSettings').toString()]: 'APP_SETTINGS'
};
 
function serializeWithSymbols(obj: any): string {
const replacer = (key: string, value: any) => {
  // Преобразуем символьные ключи в строки при сериализации
  if (typeof key === 'symbol') {
    return { __isSymbol: true, key: symbolMap[key.toString()] };
  }
  return value;
};
 
return JSON.stringify(obj, replacer);
}

// Безопасно для сериализации
const userState = {
id: 'user-123',
name: 'John',
settings: {
  theme: 'dark'
}
};
 
// Используем символы только для методов, не для данных
class StateManager {
[Symbol.for('internal:save')](state: any) {
  localStorage.setItem('state', JSON.stringify(state));
}
}

const KEY = Symbol('someKey');
const obj = { [KEY]: 'hidden value' };
 
console.log(obj); // В консоли браузера: {}

function debugObject(obj: any): void {
console.log('Regular properties:', Object.getOwnPropertyNames(obj));
console.log('Symbol properties:', Object.getOwnPropertySymbols(obj).map(sym => ({
  symbol: sym.toString(),
  value: obj[sym]
})));
}

const ID = Symbol('id');
 
interface Entity {
name: string;
[ID]: string;
}
 
const original: Entity = {
name: "User",
[ID]: "12345"
};
 
// Создаём копию с новым именем
const copy = { ...original, name: "Admin" };
 
// Ошибка! Property 'ID' does not exist on type...
console.log(copy[ID]);

const copy: Entity = { ...original, name: "Admin" };
// Теперь TypeScript знает, что copy содержит свойство [ID]

function createDynamicComponent(id: string) {
// Создаём новый символ для каждого компонента
const componentSymbol = Symbol.for(`component:${id}`);
// ...
}
 
// Если вызывать эту функцию с разными id тысячи раз,
// все созданные символы останутся в памяти навсегда!
for (let i = 0; i < 10000; i++) {
createDynamicComponent(`dynamic-${i}`);
}

// Функция, которую мы тестируем
function enhanceUser(user: any) {
const META = Symbol('meta');
return {
  ...user,
  [META]: { lastModified: new Date() }
};
}
 
// В тесте нам нужно как-то получить доступ к META
test('enhanceUser adds metadata', () => {
const enhanced = enhanceUser({ name: 'Test' });
// Как проверить символьное свойство? У нас нет доступа к META!
})

// core.ts - Ядро нашей системы плагинов
 
// Определяем точки расширения через символы
export const PluginHooks = {
  DOCUMENT_LOAD: Symbol('plugin:document:load'),
  DOCUMENT_SAVE: Symbol('plugin:document:save'),
  TEXT_TRANSFORM: Symbol('plugin:text:transform'),
  RENDER_AUGMENTATION: Symbol('plugin:render:augment')
} as const;
 
// Типы данных для каждого хука
export interface DocumentData {
  content: string;
  metadata: Record<string, unknown>;
}
 
// Типизированные интерфейсы для каждого типа плагина
export interface PluginHandlerMap {
  [PluginHooks.DOCUMENT_LOAD]: (data: DocumentData) => DocumentData;
  [PluginHooks.DOCUMENT_SAVE]: (data: DocumentData) => DocumentData;
  [PluginHooks.TEXT_TRANSFORM]: (text: string) => string;
  [PluginHooks.RENDER_AUGMENTATION]: (element: HTMLElement, content: string) => void;
}
 
// Менеджер плагинов с типобезопасной регистрацией
export class PluginManager {
  private handlers: Map<symbol, Array<any>> = new Map();
 
  // Типобезопасная регистрация обработчиков
  registerHandler<T extends keyof PluginHandlerMap>(
    hook: T,
    handler: PluginHandlerMap[T]
  ): void {
    if (!this.handlers.has(hook)) {
      this.handlers.set(hook, []);
    }
    this.handlers.get(hook)!.push(handler);
  }
 
  // Типобезопасное выполнение хуков
  executeHook<T extends keyof PluginHandlerMap>(
    hook: T,
    ...args: Parameters<PluginHandlerMap[T]>
  ): ReturnType<PluginHandlerMap[T]> | undefined {
    const handlers = this.handlers.get(hook) || [];
    let result: any = args[0];
    
    for (const handler of handlers) {
      result = handler(result);
    }
    
    return result;
  }
}

// editor.ts - Редактор с поддержкой плагинов
 
import { PluginManager, PluginHooks, DocumentData } from './core';
 
export class DocumentEditor {
  private plugins: PluginManager;
  private currentDocument: DocumentData = {
    content: '',
    metadata: {}
  };
 
  constructor() {
    this.plugins = new PluginManager();
  }
 
  // Публичный API для регистрации плагинов
  use<T extends keyof PluginHandlerMap>(
    hook: T,
    handler: PluginHandlerMap[T]
  ): this {
    this.plugins.registerHandler(hook, handler);
    return this;
  }
 
  // Загрузка документа с обработкой плагинами
  loadDocument(rawData: DocumentData): void {
    // Применяем плагины обработки загрузки
    this.currentDocument = this.plugins.executeHook(
      PluginHooks.DOCUMENT_LOAD,
      rawData
    ) || rawData;
    
    this.render();
  }
 
  // Сохранение документа с обработкой плагинами
  saveDocument(): DocumentData {
    return this.plugins.executeHook(
      PluginHooks.DOCUMENT_SAVE,
      this.currentDocument
    ) || this.currentDocument;
  }
 
  // Рендеринг с учетом плагинов
  private render(): void {
    const container = document.getElementById('editor') as HTMLElement;
    if (!container) return;
    
    // Применяем текстовые трансформации
    let content = this.plugins.executeHook(
      PluginHooks.TEXT_TRANSFORM,
      this.currentDocument.content
    ) || this.currentDocument.content;
    
    container.innerHTML = content;
    
    // Применяем расширения рендеринга
    this.plugins.executeHook(
      PluginHooks.RENDER_AUGMENTATION,
      container,
      content
    );
  }
}

// plugins.ts - Примеры плагинов
 
import { PluginHooks } from './core';
import { DocumentEditor } from './editor';
 
// Плагин автоматического сохранения версий
const versioningPlugin = (editor: DocumentEditor) => {
  editor.use(PluginHooks.DOCUMENT_SAVE, (data) => {
    return {
      ...data,
      metadata: {
        ...data.metadata,
        version: ((data.metadata.version as number) || 0) + 1,
        lastSaved: new Date().toISOString()
      }
    };
  });
};
 
// Плагин для синтаксического выделения кода
const syntaxHighlightPlugin = (editor: DocumentEditor) => {
  // Трансформация текста для подсветки кода
  editor.use(PluginHooks.TEXT_TRANSFORM, (text) => {
    return text.replace(
      /`{3}(typescript|js)([\s\S]*?)`{3}/g,
      '<pre class="code-block">$2</pre>'
    );
  });
  
  // Добавление стилей после рендеринга
  editor.use(PluginHooks.RENDER_AUGMENTATION, (element) => {
    const codeBlocks = element.querySelectorAll('.code-block');
    codeBlocks.forEach(block => {
      // Применяем подсветку синтаксиса
      highlightCode(block as HTMLElement);
    });
  });
};
 
// Вспомогательная функция подсветки кода
function highlightCode(element: HTMLElement): void {
  // Реализация подсветки синтаксиса
}
 
// Использование
const editor = new DocumentEditor();
versioningPlugin(editor);
syntaxHighlightPlugin(editor);