@pravosleva/reactive-engine 1.3.1-beta → 1.4.1-beta

package/dist/esm/mockServiceWorker.js

@@ -1,361 +0,0 @@
-/* eslint-disable */
-/* tslint:disable */
-
-/**
- * Mock Service Worker.
- * @see https://github.com/mswjs/msw
- * - Please do NOT modify this file.
- */
-
-const PACKAGE_VERSION = '2.15.0'
-const INTEGRITY_CHECKSUM = '03cb67ac84128e63d7cd722a6e5b7f1e'
-const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
-const activeClientIds = new Set()
-
-addEventListener('install', function () {
-  self.skipWaiting()
-})
-
-addEventListener('activate', function (event) {
-  event.waitUntil(self.clients.claim())
-})
-
-addEventListener('message', async function (event) {
-  const clientId = Reflect.get(event.source || {}, 'id')
-
-  if (!clientId || !self.clients) {
-    return
-  }
-
-  const client = await self.clients.get(clientId)
-
-  if (!client) {
-    return
-  }
-
-  const allClients = await self.clients.matchAll({
-    type: 'window',
-  })
-
-  switch (event.data) {
-    case 'KEEPALIVE_REQUEST': {
-      sendToClient(client, {
-        type: 'KEEPALIVE_RESPONSE',
-      })
-      break
-    }
-
-    case 'INTEGRITY_CHECK_REQUEST': {
-      sendToClient(client, {
-        type: 'INTEGRITY_CHECK_RESPONSE',
-        payload: {
-          packageVersion: PACKAGE_VERSION,
-          checksum: INTEGRITY_CHECKSUM,
-        },
-      })
-      break
-    }
-
-    case 'MOCK_ACTIVATE': {
-      activeClientIds.add(clientId)
-
-      sendToClient(client, {
-        type: 'MOCKING_ENABLED',
-        payload: {
-          client: {
-            id: client.id,
-            frameType: client.frameType,
-          },
-        },
-      })
-      break
-    }
-
-    case 'CLIENT_CLOSED': {
-      activeClientIds.delete(clientId)
-
-      const remainingClients = allClients.filter((client) => {
-        return client.id !== clientId
-      })
-
-      // Unregister itself when there are no more clients
-      if (remainingClients.length === 0) {
-        self.registration.unregister()
-      }
-
-      break
-    }
-  }
-})
-
-addEventListener('fetch', function (event) {
-  const requestInterceptedAt = Date.now()
-
-  // Bypass navigation requests.
-  if (event.request.mode === 'navigate') {
-    return
-  }
-
-  // Opening the DevTools triggers the "only-if-cached" request
-  // that cannot be handled by the worker. Bypass such requests.
-  if (
-    event.request.cache === 'only-if-cached' &&
-    event.request.mode !== 'same-origin'
-  ) {
-    return
-  }
-
-  // Bypass all requests when there are no active clients.
-  // Prevents the self-unregistered worked from handling requests
-  // after it's been terminated (still remains active until the next reload).
-  if (activeClientIds.size === 0) {
-    return
-  }
-
-  const requestId = crypto.randomUUID()
-  event.respondWith(handleRequest(event, requestId, requestInterceptedAt))
-})
-
-/**
- * @param {FetchEvent} event
- * @param {string} requestId
- * @param {number} requestInterceptedAt
- */
-async function handleRequest(event, requestId, requestInterceptedAt) {
-  const client = await resolveMainClient(event)
-  const requestCloneForEvents = event.request.clone()
-  const response = await getResponse(
-    event,
-    client,
-    requestId,
-    requestInterceptedAt,
-  )
-
-  // Send back the response clone for the "response:*" life-cycle events.
-  // Ensure MSW is active and ready to handle the message, otherwise
-  // this message will pend indefinitely.
-  if (client && activeClientIds.has(client.id)) {
-    const serializedRequest = await serializeRequest(requestCloneForEvents)
-
-    // Omit the body of server-sent event stream responses.
-    // Cloning such responses would prevent client-side stream cancelations
-    // from reaching the original stream (a teed stream only cancels its
-    // source once both of its branches cancel) and would buffer the
-    // entire stream into the unconsumed clone indefinitely.
-    const isEventStreamResponse = response.headers
-      .get('content-type')
-      ?.toLowerCase()
-      .startsWith('text/event-stream')
-
-    // Clone the response so both the client and the library could consume it.
-    const responseClone = isEventStreamResponse ? null : response.clone()
-
-    sendToClient(
-      client,
-      {
-        type: 'RESPONSE',
-        payload: {
-          isMockedResponse: IS_MOCKED_RESPONSE in response,
-          request: {
-            id: requestId,
-            ...serializedRequest,
-          },
-          response: {
-            type: response.type,
-            status: response.status,
-            statusText: response.statusText,
-            headers: Object.fromEntries(response.headers.entries()),
-            body: responseClone ? responseClone.body : null,
-          },
-        },
-      },
-      responseClone && responseClone.body
-        ? [serializedRequest.body, responseClone.body]
-        : [],
-    )
-  }
-
-  return response
-}
-
-/**
- * Resolve the main client for the given event.
- * Client that issues a request doesn't necessarily equal the client
- * that registered the worker. It's with the latter the worker should
- * communicate with during the response resolving phase.
- * @param {FetchEvent} event
- * @returns {Promise<Client | undefined>}
- */
-async function resolveMainClient(event) {
-  const client = await self.clients.get(event.clientId)
-
-  if (activeClientIds.has(event.clientId)) {
-    return client
-  }
-
-  if (client?.frameType === 'top-level') {
-    return client
-  }
-
-  const allClients = await self.clients.matchAll({
-    type: 'window',
-  })
-
-  return allClients
-    .filter((client) => {
-      // Get only those clients that are currently visible.
-      return client.visibilityState === 'visible'
-    })
-    .find((client) => {
-      // Find the client ID that's recorded in the
-      // set of clients that have registered the worker.
-      return activeClientIds.has(client.id)
-    })
-}
-
-/**
- * @param {FetchEvent} event
- * @param {Client | undefined} client
- * @param {string} requestId
- * @param {number} requestInterceptedAt
- * @returns {Promise<Response>}
- */
-async function getResponse(event, client, requestId, requestInterceptedAt) {
-  // Clone the request because it might've been already used
-  // (i.e. its body has been read and sent to the client).
-  const requestClone = event.request.clone()
-
-  function passthrough() {
-    // Cast the request headers to a new Headers instance
-    // so the headers can be manipulated with.
-    const headers = new Headers(requestClone.headers)
-
-    // Remove the "accept" header value that marked this request as passthrough.
-    // This prevents request alteration and also keeps it compliant with the
-    // user-defined CORS policies.
-    const acceptHeader = headers.get('accept')
-    if (acceptHeader) {
-      const values = acceptHeader.split(',').map((value) => value.trim())
-      const filteredValues = values.filter(
-        (value) => value !== 'msw/passthrough',
-      )
-
-      if (filteredValues.length > 0) {
-        headers.set('accept', filteredValues.join(', '))
-      } else {
-        headers.delete('accept')
-      }
-    }
-
-    return fetch(requestClone, { headers })
-  }
-
-  // Bypass mocking when the client is not active.
-  if (!client) {
-    return passthrough()
-  }
-
-  // Bypass initial page load requests (i.e. static assets).
-  // The absence of the immediate/parent client in the map of the active clients
-  // means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet
-  // and is not ready to handle requests.
-  if (!activeClientIds.has(client.id)) {
-    return passthrough()
-  }
-
-  // Notify the client that a request has been intercepted.
-  const serializedRequest = await serializeRequest(event.request)
-  const clientMessage = await sendToClient(
-    client,
-    {
-      type: 'REQUEST',
-      payload: {
-        id: requestId,
-        interceptedAt: requestInterceptedAt,
-        ...serializedRequest,
-      },
-    },
-    [serializedRequest.body],
-  )
-
-  switch (clientMessage.type) {
-    case 'MOCK_RESPONSE': {
-      return respondWithMock(clientMessage.data)
-    }
-
-    case 'PASSTHROUGH': {
-      return passthrough()
-    }
-  }
-
-  return passthrough()
-}
-
-/**
- * @param {Client} client
- * @param {any} message
- * @param {Array<Transferable>} transferrables
- * @returns {Promise<any>}
- */
-function sendToClient(client, message, transferrables = []) {
-  return new Promise((resolve, reject) => {
-    const channel = new MessageChannel()
-
-    channel.port1.onmessage = (event) => {
-      if (event.data && event.data.error) {
-        return reject(event.data.error)
-      }
-
-      resolve(event.data)
-    }
-
-    client.postMessage(message, [
-      channel.port2,
-      ...transferrables.filter(Boolean),
-    ])
-  })
-}
-
-/**
- * @param {Response} response
- * @returns {Response}
- */
-function respondWithMock(response) {
-  // Setting response status code to 0 is a no-op.
-  // However, when responding with a "Response.error()", the produced Response
-  // instance will have status code set to 0. Since it's not possible to create
-  // a Response instance with status code 0, handle that use-case separately.
-  if (response.status === 0) {
-    return Response.error()
-  }
-
-  const mockedResponse = new Response(response.body, response)
-
-  Reflect.defineProperty(mockedResponse, IS_MOCKED_RESPONSE, {
-    value: true,
-    enumerable: true,
-  })
-
-  return mockedResponse
-}
-
-/**
- * @param {Request} request
- */
-async function serializeRequest(request) {
-  return {
-    url: request.url,
-    mode: request.mode,
-    method: request.method,
-    headers: Object.fromEntries(request.headers.entries()),
-    cache: request.cache,
-    credentials: request.credentials,
-    destination: request.destination,
-    integrity: request.integrity,
-    redirect: request.redirect,
-    referrer: request.referrer,
-    referrerPolicy: request.referrerPolicy,
-    body: await request.arrayBuffer(),
-    keepalive: request.keepalive,
-  }
-}

package/dist/esm/react/ReactiveEngine4React.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ReactiveEngine4React.mjs","names":[],"sources":["../../../src/react/ReactiveEngine4React.ts"],"sourcesContent":["import { useState as useStateFromReact, useEffect as useEffectFromReact } from 'react'\nimport { ReactiveEngine as OriginalReactiveEngine, CleanupFn } from '../core/core'\n\n/**\n * Класс адаптера для интеграции реактивного движка с React.\n * Наследует функциональность оригинального реактивного движка и предоставляет специализированные методы для работы с React.\n */\nexport class ReactiveEngine4React extends OriginalReactiveEngine {\n  // Описываем строгие типы для адаптеров React, чтобы не ломать встроенные типы React.\n  private reactAdapters: {\n    useState: typeof useStateFromReact;\n    useEffect: typeof useEffectFromReact;\n  } = {\n      useState: useStateFromReact,\n      useEffect: useEffectFromReact,\n    };\n\n  /**\n   * Установка адаптеров React.\n   * @function setReactAdapters\n   * @param {Function} useState - Функция useState из React.\n   * @param {Function} useEffect - Функция useEffect из React.\n   * @returns {void}\n   * @source\n   */\n  public setReactAdapters(\n    useState: typeof useStateFromReact,\n    useEffect: typeof useEffectFromReact\n  ): void {\n    this.reactAdapters = { useState, useEffect };\n  }\n\n  /**\n   * Использование реактивного значения в React компоненте.\n   * @template T\n   * @function use\n   * @param {{ value: T; subscribe: (cb: (v: T) => void) => CleanupFn }} item - Реактивный объект.\n   * @returns {T} - Значение реактивного объекта.\n   * @source\n   */\n  public use<T>(item: { value: T; subscribe: (cb: (v: T) => void) => CleanupFn }): T {\n    if (!this.reactAdapters) {\n      throw new Error(\"[React Error]: Адаптеры React не установлены. Вызовите engine.setReactAdapters(useState, useEffect).\");\n    }\n\n    // NOTE: (защита) проверяем, что нам передали объект сигнала\n    if (!item || typeof item.subscribe !== 'function') {\n      const errorMsg = `\n        [Reactive Error]: engine.use() получил некорректный объект!\n        Скорее всего, вы пытаетесь подписаться на свойство сервиса, которое не было инициализировано.\n        Проверьте, что в классе написано: public mySignal = this.engine.signal(...)\n      `;\n      console.error(errorMsg, { item });\n      throw new Error(errorMsg);\n    }\n    const [val, setVal] = this.reactAdapters.useState(item.value);\n\n    this.reactAdapters.useEffect(\n      () => {\n        return item.subscribe(setVal);\n      },\n      [item]\n    );\n\n    return val;\n  }\n}\n"],"mappings":";;;AAOA,IAAa,IAAb,cAA0C,EAAuB;CAE/D,gBAGI;EACU;EACC;CACb;CAUF,iBACE,GACA,GACM;EACN,KAAK,gBAAgB;GAAE;GAAU;EAAU;CAC7C;CAUA,IAAc,GAAqE;EACjF,IAAI,CAAC,KAAK,eACR,MAAU,MAAM,sGAAsG;EAIxH,IAAI,CAAC,KAAQ,OAAO,EAAK,aAAc,YAAY;GACjD,IAAM,IAAW;GAMjB,MADA,QAAQ,MAAM,GAAU,EAAE,QAAK,CAAC,GACtB,MAAM,CAAQ;EAC1B;EACA,IAAM,CAAC,GAAK,KAAU,KAAK,cAAc,SAAS,EAAK,KAAK;EAS5D,OAPA,KAAK,cAAc,gBAER,EAAK,UAAU,CAAM,GAE9B,CAAC,CAAI,CACP,GAEO;CACT;AACF"}

package/dist/esm/react/hooks/useReactiveSubscription/useReactiveSubscription.mjs

@@ -1,14 +0,0 @@
-import { useEffect as e, useRef as t } from "react";
-//#region src/react/hooks/useReactiveSubscription/useReactiveSubscription.ts
-var n = (n, r) => {
-	let i = t(r);
-	e(() => {
-		i.current = r;
-	}, [r]), e(() => n.subscribe((e) => {
-		i.current(e);
-	}), [n]);
-};
-//#endregion
-export { n as useReactiveSubscription };
-
-//# sourceMappingURL=useReactiveSubscription.mjs.map

package/dist/esm/react/hooks/useReactiveSubscription/useReactiveSubscription.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useReactiveSubscription.mjs","names":[],"sources":["../../../../../src/react/hooks/useReactiveSubscription/useReactiveSubscription.ts"],"sourcesContent":["import { useEffect, useRef } from 'react'\nimport { Signal, CleanupFn } from '../../../core'\n\n/**\n * Универсальный хук для подписки на изменения Signal, Computed или Resource.\n * @template T Тип данных внутри реактивного контейнера\n * @param {Signal<T> | { subscribe: (cb: (val: T) => void) => CleanupFn }} signal Объект подписки\n * @param {(val: T) => void} callback Функция обратного вызова, принимающая новое значение\n * @source\n */\nexport const useReactiveSubscription = <T>(\n  signal: Pick<Signal<T>, 'subscribe'>,\n  callback: (val: T) => void\n): void => {\n  // Сохраняем актуальный callback в ref, чтобы не перезапускать эффект при его изменении\n  const callbackRef = useRef(callback)\n\n  useEffect(() => {\n    callbackRef.current = callback\n  }, [callback])\n\n  useEffect(() => {\n    // Подписываемся один раз при изменении самого signal\n    const unsubscribe: CleanupFn = signal.subscribe((val) => {\n      callbackRef.current(val)\n    })\n\n    // Возвращаем функцию очистки для автоматической отписки при размонтировании\n    return unsubscribe\n  }, [signal])\n}\n"],"mappings":";;AAUA,IAAa,KACX,GACA,MACS;CAET,IAAM,IAAc,EAAO,CAAQ;CAMnC,AAJA,QAAgB;EACd,EAAY,UAAU;CACxB,GAAG,CAAC,CAAQ,CAAC,GAEb,QAEiC,EAAO,WAAW,MAAQ;EACvD,EAAY,QAAQ,CAAG;CACzB,CAGO,GACN,CAAC,CAAM,CAAC;AACb"}

package/dist/esm/react/hooks/useReactiveValue/useReactiveValue.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useReactiveValue.mjs","names":[],"sources":["../../../../../src/react/hooks/useReactiveValue/useReactiveValue.ts"],"sourcesContent":["import { useSyncExternalStore, useCallback, useMemo, useEffect, useRef } from 'react'\nimport { CleanupFn } from '../../../core'\n\ninterface ObservableItem<T> {\n  readonly value: T;\n  subscribe: (cb: (val: T) => void) => CleanupFn\n  destroy?: () => void\n}\n\ntype ReactiveInput<T> = ObservableItem<T> | (() => ObservableItem<T>)\n\n/**\n * Нативный React-хук для извлечения текущего значения из реактивных примитивов ядра\n * (Signal, Computed, Resource) и автоматического управления подпиской на рендеринг.\n *\n * Опирается на каноничную шим-прослойку `useSyncExternalStore`, что гарантирует 100%\n * совместимость с механизмами батчинга обновлений React 18+ и Concurrent Mode (защита от Tearing).\n *\n * ### Особенности управления памятью:\n * 1. **Глобальные сигналы (Сервисы/Синглтоны):** При размонтировании компонента хук выполняет\n *    только стандартную отписку от обновлений. Метод `.destroy()` **не вызывается**,\n *    что сохраняет глобальное состояние системы в безопасности.\n * 2. **Локальные фабрики (`() => engine.computed(...)`):** Если в качестве аргумента передана\n *    функция-фабрика, хук понимает, что вычисление создано локально для этого экрана.\n *    При анмаунте компонента хук автоматически вызовет `.destroy()`, предотвращая утечки памяти в ядре.\n *\n * @template T - Тип данных, инкапсулированных внутри реактивного элемента.\n * @param {ReactiveInput<T>} input - Готовый реактивный элемент ядра или ленивая функция-фабрика, возвращающая его.\n * @returns {T} Актуальное синхронизированное значение реактивного элемента.\n *\n * @example\n * ```tsx\n * import { useReactiveValue } from '@pravosleva/reactive-engine/react';\n * import { userInfoService } from '~/store';\n *\n * // Сценарий 1: Прямая подписка на долгоживущий сигнал сервиса\n * export const CounterDisplay = () => {\n *   const counter = useReactiveValue(userInfoService.counter);\n *   return <span>Значение: {counter}</span>;\n * };\n *\n * // Сценарий 2: Использование ленивой фабрики для локальных вычислений (авто-очистка ядра при анмаунте)\n * export const FilteredList = ({ query }: { query: string }) => {\n *   const filteredData = useReactiveValue(() =>\n *     engine.computed(() => userInfoService.list.value.filter(item => item.includes(query)))\n *   );\n *   return <ul>{filteredData.map(item => <li key={item}>{item}</li>)}</ul>;\n * };\n * ```\n */\nexport const useReactiveValue = <T>(input: ReactiveInput<T>): T => {\n  const isFactory = typeof input === 'function';\n\n  // NOTE: СТАБИЛИЗАЦИЯ ФАБРИКИ: Сохраняем ссылку на функцию в ref,\n  // чтобы не перезапускать вычисления, если разработчик передал инлайн-стрелочную функцию.\n  const factoryRef = useRef(input);\n  useEffect(() => {\n    factoryRef.current = input;\n  }, [input]);\n\n  // Вычисляем элемент строго один раз при инициализации, либо при изменении стабильной ссылки на готовый сигнал\n  const reactiveItem = useMemo(() => {\n    if (typeof input === 'function') {\n      // Вызываем фабрику только при первом проходе\n      return input();\n    }\n    return input; // Если передан готовый сигнал/ресурс — используем его напрямую\n  }, [isFactory ? undefined : input]); // Стабильный массив зависимостей для фабрик!\n\n  const subscribe = useCallback(\n    (reactCallback: () => void) => {\n      return reactiveItem.subscribe(reactCallback)\n    },\n    [reactiveItem]\n  )\n\n  const getSnapshot = useCallback(() => {\n    return reactiveItem.value\n  }, [reactiveItem])\n\n  // NOTE: БЕЗОПАСНАЯ ОЧИСТКА ПАМЯТИ:\n  // Вызываем .destroy() ТОЛЬКО если объект пришел из локальной фабрики `() => engine.computed(...)`.\n  // Если это глобальный сигнал из сервиса — мы делаем только стандартный unmount подписки через useSyncExternalStore.\n  useEffect(() => {\n    return () => {\n      if (isFactory && reactiveItem && typeof reactiveItem.destroy === 'function') {\n        reactiveItem.destroy();\n      }\n    }\n  }, [reactiveItem, isFactory])\n\n  return useSyncExternalStore(subscribe, getSnapshot)\n}\n"],"mappings":";;AAkDA,IAAa,KAAuB,MAA+B;CACjE,IAAM,IAAY,OAAO,KAAU,YAI7B,IAAa,EAAO,CAAK;CAC/B,QAAgB;EACd,EAAW,UAAU;CACvB,GAAG,CAAC,CAAK,CAAC;CAGV,IAAM,IAAe,QACf,OAAO,KAAU,aAEZ,EAAM,IAER,GACN,CAAC,IAAY,KAAA,IAAY,CAAK,CAAC,GAE5B,IAAY,GACf,MACQ,EAAa,UAAU,CAAa,GAE7C,CAAC,CAAY,CACf,GAEM,IAAc,QACX,EAAa,OACnB,CAAC,CAAY,CAAC;CAajB,OARA,cACe;EACX,AAAI,KAAa,KAAgB,OAAO,EAAa,WAAY,cAC/D,EAAa,QAAQ;CAEzB,GACC,CAAC,GAAc,CAAS,CAAC,GAErB,EAAqB,GAAW,CAAW;AACpD"}

package/dist/esm/react/hooks/useReactiveValue0/useReactiveValue0.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useReactiveValue0.mjs","names":[],"sources":["../../../../../src/react/hooks/useReactiveValue0/useReactiveValue0.ts"],"sourcesContent":["import { useState, useEffect, useRef, useMemo } from 'react'\nimport { CleanupFn } from '../../../core'\n\ninterface ObservableItem<T> {\n  readonly value: T\n  subscribe: (cb: (val: T) => void) => CleanupFn\n  destroy?: () => void\n}\n\ntype ReactiveInput<T> = ObservableItem<T> | (() => ObservableItem<T>)\n\n/**\n * Изоморфный фоллбэк-хук для извлечения текущего значения из реактивных примитивов ядра\n * (Signal, Computed, Resource) и управления подпиской в окружениях **React 16.8+ и React 17**.\n *\n * В отличие от современной версии `useReactiveValue`, данный хук спроектирован на базе классической\n * связки `useState` + `useEffect`. Он содержит встроенный механизм упреждающей синхронизации\n * (Pre-emptive Synchronization Pattern), предотвращающий рассинхронизацию данных (Tearing) и мерцание UI\n * во время асинхронных микрозадач планировщика React.\n *\n * ### Особенности управления памятью:\n * 1. **Глобальные сигналы (Сервисы/Синглтоны):** При размонтировании компонента хук выполняет\n *    только стандартную отписку от обновлений. Метод `.destroy()` **не вызывается**,\n *    что сохраняет глобальное состояние системы в безопасности.\n * 2. **Локальные фабрики (`() => engine.computed(...)`):** Если в качестве аргумента передана\n *    функция-фабрика, хук понимает, что вычисление создано локально для этого экрана.\n *    При анмаунте компонента хук автоматически вызовет `.destroy()`, предотвращая утечки памяти в ядре.\n *\n * @template T - Тип данных, инкапсулированных внутри реактивного элемента.\n * @param {ReactiveInput<T>} input - Готовый реактивный элемент ядра или ленивая функция-фабрика, возвращающая его.\n * @returns {T} Актуальное синхронизированное значение реактивного элемента.\n *\n * @example\n * ```tsx\n * import { useReactiveValue0 } from '@pravosleva/reactive-engine/react';\n * import { userInfoService } from '~/store';\n *\n * // Сценарий 1: Прямая подписка на долгоживущий сигнал сервиса в legacy-компоненте\n * export const LegacyCounterDisplay = () => {\n *   const counter = useReactiveValue0(userInfoService.counter);\n *   return <span>Значение: {counter}</span>;\n * };\n *\n * // Сценарий 2: Использование ленивой фабрики во React 17 проектах (авто-очистка ядра при анмаунте)\n * export const LegacyFilteredList = ({ query }: { query: string }) => {\n *   const filteredData = useReactiveValue0(() =>\n *     engine.computed(() => userInfoService.list.value.filter(item => item.includes(query)))\n *   );\n *   return <ul>{filteredData.map(item => <li key={item}>{item}</li>)}</ul>;\n * };\n * ```\n */\nexport const useReactiveValue0 = <T>(input: ReactiveInput<T>): T => {\n  const isFactory = typeof input === 'function';\n\n  // NOTE: СТАБИЛИЗАЦИЯ ИНПУТА: защищает от бесконечных циклов при инлайн-стрелочных фабриках\n  const factoryRef = useRef(input);\n  useEffect(() => {\n    factoryRef.current = input;\n  }, [input]);\n\n  // Вычисляем элемент строго 1 раз при монтировании, либо при смене ссылки на готовый сигнал\n  const reactiveItem = useMemo(() => {\n    if (typeof input === 'function') {\n      return input(); // Ленивый вызов фабрики ровно один раз за жизнь компонента\n    }\n    return input;\n  }, [isFactory ? undefined : input]); // Игнорируем ссылки инлайн-функций\n\n  const [state, setState] = useState<T>(reactiveItem.value)\n  const setStateRef = useRef(setState)\n\n  // Держим ссылку на setState всегда актуальной для безопасных асинхронных вызовов\n  useEffect(() => {\n    setStateRef.current = setState\n  }, [setState])\n\n  // NOTE: СИНХРОНИЗАЦИЯ НА ОПЕРЕЖЕНИЕ (Теккущее значение):\n  // Если между фазой рендера и выполнением useEffect значение в ядре библиотеки успело измениться,\n  // мы синхронно подтягиваем актуальный стейт, исключая \"слепые пятна\" и мерцание UI.\n  if (state !== reactiveItem.value) {\n    setState(reactiveItem.value);\n  }\n\n  useEffect(() => {\n    // Привязываем подписку ядра к триггеру обновлений React\n    const unsubscribe = reactiveItem.subscribe((newValue) => {\n      setStateRef.current(newValue)\n    })\n\n    return () => {\n      unsubscribe();\n\n      // NOTE: БЕЗОПАСНАЯ ОЧИСТКА ПАМЯТИ:\n      // Метод .destroy() вызывается СТРОГО если объект был порожден локальной фабрикой.\n      // Глобальные сигналы сервисов остаются в безопасности и не стираются из движка!\n      if (isFactory && reactiveItem && typeof reactiveItem.destroy === 'function') {\n        reactiveItem.destroy()\n      }\n    }\n  }, [reactiveItem, isFactory])\n\n  return state\n}\n"],"mappings":";;AAoDA,IAAa,KAAwB,MAA+B;CAClE,IAAM,IAAY,OAAO,KAAU,YAG7B,IAAa,EAAO,CAAK;CAC/B,QAAgB;EACd,EAAW,UAAU;CACvB,GAAG,CAAC,CAAK,CAAC;CAGV,IAAM,IAAe,QACf,OAAO,KAAU,aACZ,EAAM,IAER,GACN,CAAC,IAAY,KAAA,IAAY,CAAK,CAAC,GAE5B,CAAC,GAAO,KAAY,EAAY,EAAa,KAAK,GAClD,IAAc,EAAO,CAAQ;CAgCnC,OA7BA,QAAgB;EACd,EAAY,UAAU;CACxB,GAAG,CAAC,CAAQ,CAAC,GAKT,MAAU,EAAa,SACzB,EAAS,EAAa,KAAK,GAG7B,QAAgB;EAEd,IAAM,IAAc,EAAa,WAAW,MAAa;GACvD,EAAY,QAAQ,CAAQ;EAC9B,CAAC;EAED,aAAa;GAMX,AALA,EAAY,GAKR,KAAa,KAAgB,OAAO,EAAa,WAAY,cAC/D,EAAa,QAAQ;EAEzB;CACF,GAAG,CAAC,GAAc,CAAS,CAAC,GAErB;AACT"}

package/dist/esm/utils/getExtractedValues.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"getExtractedValues.mjs","names":[],"sources":["../../../src/utils/getExtractedValues.ts"],"sourcesContent":["export const getExtractedValues = ({\n  tested, expectedKey, valueType\n}: {\n  tested: string[];\n  expectedKey: string;\n  valueType: 'number' | 'string';\n}): string[] => {\n  const results: string[] = [];\n  for (let i = 0, max = tested.length; i < max; i++) {\n    const t = tested[i];\n    let regex;\n    switch (valueType) {\n      case 'number':\n        regex = new RegExp(`\\\\[${expectedKey}=(?<value>\\\\d+)\\\\]`, 'g');\n        break;\n      case 'string':\n      default:\n        // NOTE: \"Ленивый\" квантификатор -> \".*?\" будет искать минимальное количество символов до следующего экранированного \"]\"\n        regex = new RegExp(`\\\\[${expectedKey}=(?<value>.*?)\\\\]`, 'g');\n        break;\n    }\n\n    // eslint-disable-next-line no-restricted-syntax\n    for (const n of t.matchAll(regex)) {\n      if (n?.groups) { results.push(n.groups.value); }\n    }\n  }\n  return results;\n};\n"],"mappings":";AAAA,IAAa,KAAsB,EACjC,WAAQ,gBAAa,mBAKP;CACd,IAAM,IAAoB,CAAC;CAC3B,KAAK,IAAI,IAAI,GAAG,IAAM,EAAO,QAAQ,IAAI,GAAK,KAAK;EACjD,IAAM,IAAI,EAAO,IACb;EACJ,QAAQ,GAAR;GACE,KAAK;IACH,IAAY,OAAO,MAAM,EAAY,qBAAqB,GAAG;IAC7D;GAEF;IAEE,IAAY,OAAO,MAAM,EAAY,oBAAoB,GAAG;IAC5D;EACJ;EAGA,KAAK,IAAM,KAAK,EAAE,SAAS,CAAK,GAC9B,AAAI,GAAG,UAAU,EAAQ,KAAK,EAAE,OAAO,KAAK;CAEhD;CACA,OAAO;AACT"}

package/dist/esm/vite.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

package/dist/esm/vue/ReactiveEngine4Vue.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ReactiveEngine4Vue.mjs","names":[],"sources":["../../../src/vue/ReactiveEngine4Vue.ts"],"sourcesContent":["import { shallowRef, onUnmounted, getCurrentInstance, getCurrentScope, onScopeDispose, triggerRef, type ShallowRef } from 'vue'\nimport { ReactiveEngine as OriginalReactiveEngine, type CleanupFn } from '../core/core'\n\nexport class ReactiveEngine4Vue extends OriginalReactiveEngine {\n  /**\n   * Использование реактивного значения в Vue компоненте или EffectScope.\n   */\n  public use<T>(item: { value: T; subscribe: (cb: (v: T) => void) => CleanupFn }): ShallowRef<T> {\n    // Создаем локальную Vue-реактивную обертку со стартовым значением сигнала\n    const state = shallowRef(item.value)\n\n    // Подписываемся на изменения сигнала ядра\n    const unsubscribe = item.subscribe((newValue) => {\n      state.value = newValue // Обновляем Vue-реактивную переменную\n      triggerRef(state)      // 👈 ПРИНУДИТЕЛЬНО заставляем Vue перерисовать шаблон\n    })\n\n    // Проверяем наличие активного компонента ИЛИ active области видимости эффектов\n\n    // 1. Если мы находимся внутри жизненного цикла компонента Vue (setup)\n    if (getCurrentInstance()) {\n      // Автоматически отписываемся при размонтировании Vue-компонента\n      onUnmounted(() => {\n        unsubscribe()\n      })\n    }\n    // 2. Иначе, если мы находимся внутри изолированного EffectScope (например, в Pinia или в тестах)\n    else if (getCurrentScope()) {\n      onScopeDispose(() => {\n        unsubscribe()\n      })\n    }\n\n    return state\n  }\n}\n"],"mappings":";;;AAGA,IAAa,IAAb,cAAwC,EAAuB;CAI7D,IAAc,GAAiF;EAE7F,IAAM,IAAQ,EAAW,EAAK,KAAK,GAG7B,IAAc,EAAK,WAAW,MAAa;GAE/C,AADA,EAAM,QAAQ,GACd,EAAW,CAAK;EAClB,CAAC;EAkBD,OAbI,EAAmB,IAErB,QAAkB;GAChB,EAAY;EACd,CAAC,IAGM,EAAgB,KACvB,QAAqB;GACnB,EAAY;EACd,CAAC,GAGI;CACT;AACF"}