From 86a0ea633207d8f468d0804d3ad8655a7c520630 Mon Sep 17 00:00:00 2001 From: sirse Date: Tue, 29 Oct 2024 12:40:47 +0200 Subject: [PATCH] Moved stocked into monorepo --- packages/core/package.json | 4 +- packages/dom/package.json | 4 +- packages/pxth/package.json | 2 +- packages/stocked/.prettierignore | 3 + packages/stocked/aqu.config.json | 11 + packages/stocked/eslint.config.mjs | 8 + packages/stocked/package.json | 60 + .../stocked/src/components/ProxyContext.ts | 5 + .../stocked/src/components/ProxyProvider.tsx | 24 + .../stocked/src/components/StockContext.ts | 5 + packages/stocked/src/components/StockRoot.tsx | 18 + packages/stocked/src/components/index.ts | 4 + packages/stocked/src/hooks/index.ts | 7 + .../stocked/src/hooks/useAllStockValues.ts | 14 + packages/stocked/src/hooks/useDebugStock.ts | 47 + packages/stocked/src/hooks/useMappingProxy.ts | 29 + packages/stocked/src/hooks/useObservers.ts | 149 + packages/stocked/src/hooks/useStock.ts | 106 + packages/stocked/src/hooks/useStockContext.ts | 25 + packages/stocked/src/hooks/useStockState.ts | 32 + packages/stocked/src/hooks/useStockValue.ts | 39 + packages/stocked/src/index.ts | 6 + packages/stocked/src/typings/BatchUpdate.ts | 11 + packages/stocked/src/typings/MappingProxy.ts | 143 + packages/stocked/src/typings/Observer.ts | 1 + .../stocked/src/typings/ProxyMapSource.ts | 9 + packages/stocked/src/typings/PxthMap.ts | 33 + packages/stocked/src/typings/StockProxy.ts | 57 + packages/stocked/src/typings/index.ts | 6 + packages/stocked/src/utils/ObserverArray.ts | 45 + .../stocked/src/utils/areProxyMapsEqual.ts | 22 + packages/stocked/src/utils/createProxyMap.ts | 44 + packages/stocked/src/utils/hashPxth.ts | 3 + .../stocked/src/utils/mappingProxyUtils.ts | 13 + packages/stocked/src/utils/useInterceptors.ts | 135 + packages/stocked/src/utils/useLazyRef.ts | 15 + packages/stocked/test/.eslintrc | 9 + packages/stocked/test/DummyProxy.ts | 12 + .../test/components/ProxyProvider.test.tsx | 80 + .../test/components/StockRoot.test.tsx | 80 + .../test/hooks/useAllStockValues.test.tsx | 83 + .../test/hooks/useMappingProxy.test.ts | 54 + .../stocked/test/hooks/useObservers.test.ts | 311 ++ packages/stocked/test/hooks/useStock.test.ts | 294 ++ .../test/hooks/useStockContext.test.tsx | 99 + .../stocked/test/hooks/useStockState.test.tsx | 97 + .../stocked/test/hooks/useStockValue.test.tsx | 82 + .../stocked/test/typings/MappingProxy.test.ts | 651 ++++ .../stocked/test/typings/StockProxy.test.ts | 19 + .../stocked/test/utils/ObserverArray.test.ts | 73 + .../test/utils/areProxyMapsEqual.test.ts | 130 + .../test/utils/useInterceptors.test.ts | 271 ++ .../stocked/test/utils/useLazyRef.test.ts | 31 + packages/stocked/tsconfig.json | 36 + packages/stocked/vitest.config.ts | 7 + pnpm-lock.yaml | 3150 +++++++++++++++-- 56 files changed, 6414 insertions(+), 294 deletions(-) create mode 100644 packages/stocked/.prettierignore create mode 100644 packages/stocked/aqu.config.json create mode 100644 packages/stocked/eslint.config.mjs create mode 100644 packages/stocked/package.json create mode 100644 packages/stocked/src/components/ProxyContext.ts create mode 100644 packages/stocked/src/components/ProxyProvider.tsx create mode 100644 packages/stocked/src/components/StockContext.ts create mode 100644 packages/stocked/src/components/StockRoot.tsx create mode 100644 packages/stocked/src/components/index.ts create mode 100644 packages/stocked/src/hooks/index.ts create mode 100644 packages/stocked/src/hooks/useAllStockValues.ts create mode 100644 packages/stocked/src/hooks/useDebugStock.ts create mode 100644 packages/stocked/src/hooks/useMappingProxy.ts create mode 100644 packages/stocked/src/hooks/useObservers.ts create mode 100644 packages/stocked/src/hooks/useStock.ts create mode 100644 packages/stocked/src/hooks/useStockContext.ts create mode 100644 packages/stocked/src/hooks/useStockState.ts create mode 100644 packages/stocked/src/hooks/useStockValue.ts create mode 100644 packages/stocked/src/index.ts create mode 100644 packages/stocked/src/typings/BatchUpdate.ts create mode 100644 packages/stocked/src/typings/MappingProxy.ts create mode 100644 packages/stocked/src/typings/Observer.ts create mode 100644 packages/stocked/src/typings/ProxyMapSource.ts create mode 100644 packages/stocked/src/typings/PxthMap.ts create mode 100644 packages/stocked/src/typings/StockProxy.ts create mode 100644 packages/stocked/src/typings/index.ts create mode 100644 packages/stocked/src/utils/ObserverArray.ts create mode 100644 packages/stocked/src/utils/areProxyMapsEqual.ts create mode 100644 packages/stocked/src/utils/createProxyMap.ts create mode 100644 packages/stocked/src/utils/hashPxth.ts create mode 100644 packages/stocked/src/utils/mappingProxyUtils.ts create mode 100644 packages/stocked/src/utils/useInterceptors.ts create mode 100644 packages/stocked/src/utils/useLazyRef.ts create mode 100644 packages/stocked/test/.eslintrc create mode 100644 packages/stocked/test/DummyProxy.ts create mode 100644 packages/stocked/test/components/ProxyProvider.test.tsx create mode 100644 packages/stocked/test/components/StockRoot.test.tsx create mode 100644 packages/stocked/test/hooks/useAllStockValues.test.tsx create mode 100644 packages/stocked/test/hooks/useMappingProxy.test.ts create mode 100644 packages/stocked/test/hooks/useObservers.test.ts create mode 100644 packages/stocked/test/hooks/useStock.test.ts create mode 100644 packages/stocked/test/hooks/useStockContext.test.tsx create mode 100644 packages/stocked/test/hooks/useStockState.test.tsx create mode 100644 packages/stocked/test/hooks/useStockValue.test.tsx create mode 100644 packages/stocked/test/typings/MappingProxy.test.ts create mode 100644 packages/stocked/test/typings/StockProxy.test.ts create mode 100644 packages/stocked/test/utils/ObserverArray.test.ts create mode 100644 packages/stocked/test/utils/areProxyMapsEqual.test.ts create mode 100644 packages/stocked/test/utils/useInterceptors.test.ts create mode 100644 packages/stocked/test/utils/useLazyRef.test.ts create mode 100644 packages/stocked/tsconfig.json create mode 100644 packages/stocked/vitest.config.ts diff --git a/packages/core/package.json b/packages/core/package.json index c3d24b78..6259bfa9 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -26,8 +26,8 @@ "dependencies": { "lodash": "4.17.21", "lodash-es": "4.17.15", - "pxth": "0.7.0", - "stocked": "1.0.0-beta.33", + "pxth": "workspace:*", + "stocked": "workspace:*", "tiny-invariant": "1.2.0" }, "devDependencies": { diff --git a/packages/dom/package.json b/packages/dom/package.json index 00d3d779..005c60d5 100644 --- a/packages/dom/package.json +++ b/packages/dom/package.json @@ -24,8 +24,8 @@ "test:watch": "jest --passWithNoTests --watch" }, "dependencies": { - "pxth": "0.7.0", - "stocked": "1.0.0-beta.33", + "pxth": "workspace:*", + "stocked": "workspace:*", "tiny-invariant": "1.2.0" }, "devDependencies": { diff --git a/packages/pxth/package.json b/packages/pxth/package.json index 84c15ed2..0825716f 100644 --- a/packages/pxth/package.json +++ b/packages/pxth/package.json @@ -52,7 +52,7 @@ "@arethetypeswrong/cli": "^0.16.4", "@microsoft/api-extractor": "^7.47.11", "@types/lodash": "^4.17.12", - "@types/node": "^14.14.31", + "@types/node": "^20.17.2", "eslint": "^9.13.0", "np": "^10.0.7", "tsup": "^8.3.5", diff --git a/packages/stocked/.prettierignore b/packages/stocked/.prettierignore new file mode 100644 index 00000000..913dcda0 --- /dev/null +++ b/packages/stocked/.prettierignore @@ -0,0 +1,3 @@ +.docusaurus +dist +pnpm-lock.yaml \ No newline at end of file diff --git a/packages/stocked/aqu.config.json b/packages/stocked/aqu.config.json new file mode 100644 index 00000000..0a62e676 --- /dev/null +++ b/packages/stocked/aqu.config.json @@ -0,0 +1,11 @@ +{ + "buildOptions": { + "target": ["es2019", "chrome58", "firefox57", "safari11", "node12"] + }, + "dtsBundleGeneratorOptions": { + "libraries": { + "importedLibraries": ["react", "prop-types", "scheduler", "pxth"], + "allowedTypesLibraries": [] + } + } +} diff --git a/packages/stocked/eslint.config.mjs b/packages/stocked/eslint.config.mjs new file mode 100644 index 00000000..612edb90 --- /dev/null +++ b/packages/stocked/eslint.config.mjs @@ -0,0 +1,8 @@ +import baseConfig from '@reactive-tools/eslint-config'; + +export default [ + { + ignores: ['**/dist', '**/node_modules', '**/*.config.js', '**/.tsup'], + }, + ...baseConfig, +]; diff --git a/packages/stocked/package.json b/packages/stocked/package.json new file mode 100644 index 00000000..093128e4 --- /dev/null +++ b/packages/stocked/package.json @@ -0,0 +1,60 @@ +{ + "name": "stocked", + "description": "Tiny state management library for react.", + "version": "1.0.0-beta.33", + "main": "dist/index.js", + "module": "dist/stocked.esm.js", + "repository": { + "type": "git", + "url": "git+https://github.com/fracht/reactive-forms.git", + "directory": "packages/stocked" + }, + "author": "Artiom Tretjakovas", + "license": "MIT", + "scripts": { + "analyze": "size-limit --why", + "build": "aqu build", + "build:docs": "vitepress build new-docs", + "dev:docs": "vitepress dev new-docs", + "format": "syncpack format && prettier --write \"**/*.{ts,tsx,cjs,mjs,js,jsx,json,yml,yaml,clean-publish}\"", + "lint": "eslint .", + "lint:config": "pnpm lint --write-file", + "prepublishOnly": "aqu build", + "serve:docs": "vitepress serve new-docs", + "size": "size-limit", + "start": "aqu watch", + "test": "vitest run", + "test:watch": "pnpm run test --watch" + }, + "dependencies": { + "lodash": "^4.17.21", + "pxth": "workspace:*", + "tiny-invariant": "^1.3.3" + }, + "devDependencies": { + "@testing-library/dom": "^10.4.0", + "@testing-library/react": "^16.0.1", + "@types/lodash": "^4.17.12", + "@types/react": "18.3.12", + "@types/react-dom": "18.3.1", + "aqu": "^0.4.3", + "configs": "github:fracht/configs", + "jsdom": "^25.0.1", + "react": "^18.3.1", + "react-dom": "^18.3.1", + "tslib": "2.3.1", + "typescript": "^5.6.3", + "vitepress": "^1.4.1", + "vitest": "^2.1.3" + }, + "peerDependencies": { + "react": ">=16" + }, + "engines": { + "node": ">=10" + }, + "files": [ + "dist" + ], + "typings": "dist/stocked.d.ts" +} diff --git a/packages/stocked/src/components/ProxyContext.ts b/packages/stocked/src/components/ProxyContext.ts new file mode 100644 index 00000000..a9b26ab7 --- /dev/null +++ b/packages/stocked/src/components/ProxyContext.ts @@ -0,0 +1,5 @@ +import { createContext } from 'react'; + +import { StockProxy } from '../typings/StockProxy'; + +export const ProxyContext = createContext | undefined>(undefined); diff --git a/packages/stocked/src/components/ProxyProvider.tsx b/packages/stocked/src/components/ProxyProvider.tsx new file mode 100644 index 00000000..981eb8d7 --- /dev/null +++ b/packages/stocked/src/components/ProxyProvider.tsx @@ -0,0 +1,24 @@ +import React from 'react'; +import { Pxth } from 'pxth'; + +import { ProxyContext } from './ProxyContext'; +import { StockContext } from './StockContext'; +import { useStockContext } from '../hooks'; +import { StockProxy } from '../typings'; + +export type ProxyProviderProps = { + proxy: StockProxy; + children: React.ReactNode | ((path: Pxth) => React.ReactNode); +}; + +export const ProxyProvider = ({ proxy, children }: ProxyProviderProps) => { + const stock = useStockContext(); + + return ( + + }> + {typeof children === 'function' ? children(proxy.path) : children} + + + ); +}; diff --git a/packages/stocked/src/components/StockContext.ts b/packages/stocked/src/components/StockContext.ts new file mode 100644 index 00000000..61b48c7c --- /dev/null +++ b/packages/stocked/src/components/StockContext.ts @@ -0,0 +1,5 @@ +import { createContext } from 'react'; + +import { Stock } from '../hooks/useStock'; + +export const StockContext = createContext | undefined>(undefined); diff --git a/packages/stocked/src/components/StockRoot.tsx b/packages/stocked/src/components/StockRoot.tsx new file mode 100644 index 00000000..ba4eaef7 --- /dev/null +++ b/packages/stocked/src/components/StockRoot.tsx @@ -0,0 +1,18 @@ +import React from 'react'; + +import { StockContext } from './StockContext'; +import { Stock, StockConfig, useStock } from '../hooks/useStock'; + +export type StockRootProps = StockConfig & { + children: React.ReactNode; +}; + +/** + * The main component, which should wrap all code, which uses stock values. + * Creates stock and puts it in `StockContext`. + */ +export const StockRoot = ({ children, ...stockConfig }: StockRootProps) => { + const stock = useStock(stockConfig); + + return }>{children}; +}; diff --git a/packages/stocked/src/components/index.ts b/packages/stocked/src/components/index.ts new file mode 100644 index 00000000..0df70f7f --- /dev/null +++ b/packages/stocked/src/components/index.ts @@ -0,0 +1,4 @@ +export * from './StockContext'; +export * from './StockRoot'; +export * from './ProxyContext'; +export * from './ProxyProvider'; diff --git a/packages/stocked/src/hooks/index.ts b/packages/stocked/src/hooks/index.ts new file mode 100644 index 00000000..aa362315 --- /dev/null +++ b/packages/stocked/src/hooks/index.ts @@ -0,0 +1,7 @@ +export * from './useStock'; +export * from './useStockContext'; +export * from './useStockValue'; +export * from './useStockState'; +export * from './useObservers'; +export * from './useAllStockValues'; +export * from './useMappingProxy'; diff --git a/packages/stocked/src/hooks/useAllStockValues.ts b/packages/stocked/src/hooks/useAllStockValues.ts new file mode 100644 index 00000000..a4386805 --- /dev/null +++ b/packages/stocked/src/hooks/useAllStockValues.ts @@ -0,0 +1,14 @@ +import { createPxth, Pxth } from 'pxth'; + +import { Stock } from './useStock'; +import { useStockValue } from './useStockValue'; +import { StockProxy } from '../typings/StockProxy'; + +const rootPxth = createPxth([]); + +export const useAllStockValues = ( + customStock?: Stock, + proxy?: StockProxy, +): T => { + return useStockValue(rootPxth as unknown as Pxth, customStock, proxy); +}; diff --git a/packages/stocked/src/hooks/useDebugStock.ts b/packages/stocked/src/hooks/useDebugStock.ts new file mode 100644 index 00000000..8960e615 --- /dev/null +++ b/packages/stocked/src/hooks/useDebugStock.ts @@ -0,0 +1,47 @@ +/* eslint-disable @typescript-eslint/no-explicit-any */ + +import { useEffect } from 'react'; +import { getPxthSegments } from 'pxth'; + +import { Stock } from './useStock'; + +declare global { + interface Window { + __STOCKED_DEVTOOLS_HOOK?: { + raiseEvent: (event: string, data: any) => void; + }; + } +} + +enum StockedEvent { + NEW = 'new', + BATCH_UPDATE = 'update', +} + +let stockIndex = -1; + +export const useDebugStock = (stock: Stock) => { + useEffect(() => { + if (window.__STOCKED_DEVTOOLS_HOOK) { + const currentStockId = ++stockIndex; + window.__STOCKED_DEVTOOLS_HOOK!.raiseEvent(StockedEvent.NEW, { + data: stock.getValues(), + id: currentStockId, + }); + + return stock.watchBatchUpdates((data) => + window.__STOCKED_DEVTOOLS_HOOK!.raiseEvent(StockedEvent.BATCH_UPDATE, { + data: { + ...data, + origin: getPxthSegments(data.origin), + }, + id: currentStockId, + }), + ); + } + + return () => { + /** empty fn */ + }; + }, [stock]); +}; diff --git a/packages/stocked/src/hooks/useMappingProxy.ts b/packages/stocked/src/hooks/useMappingProxy.ts new file mode 100644 index 00000000..f201d8e5 --- /dev/null +++ b/packages/stocked/src/hooks/useMappingProxy.ts @@ -0,0 +1,29 @@ +import { useEffect, useMemo, useRef } from 'react'; +import { Pxth } from 'pxth'; + +import { MappingProxy, ProxyMapSource } from '../typings'; +import { areProxyMapsEqual } from '../utils/areProxyMapsEqual'; +import { hashPxth } from '../utils/hashPxth'; + +const useMapMemo = (map: ProxyMapSource): ProxyMapSource => { + const mapRef = useRef(map); + + useEffect(() => { + if (!areProxyMapsEqual(mapRef.current, map)) { + mapRef.current = map; + } + }, [map]); + + return areProxyMapsEqual(mapRef.current, map) ? mapRef.current : map; +}; + +export const useMappingProxy = (mapSource: ProxyMapSource, path: Pxth) => { + const realMap = useMapMemo(mapSource); + + return useMemo(() => { + const proxy = new MappingProxy(realMap, path); + proxy.activate(); + return proxy; + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [hashPxth(path), realMap]); +}; diff --git a/packages/stocked/src/hooks/useObservers.ts b/packages/stocked/src/hooks/useObservers.ts new file mode 100644 index 00000000..b386f262 --- /dev/null +++ b/packages/stocked/src/hooks/useObservers.ts @@ -0,0 +1,149 @@ +import { MutableRefObject, useCallback, useRef } from 'react'; +import { createPxth, deepGet, isInnerPxth, Pxth, samePxth } from 'pxth'; +import invariant from 'tiny-invariant'; + +import { BatchUpdate, Observer } from '../typings'; +import { PxthMap } from '../typings/PxthMap'; +import { ObserverArray, ObserverKey } from '../utils/ObserverArray'; +import { useLazyRef } from '../utils/useLazyRef'; + +export type ObserversControl = { + /** + * Watch stock value. Returns cleanup function. + * @deprecated - use watchEffect instead + */ + watch: (path: Pxth, observer: Observer) => () => void; + /** + * Watch all stock values. Returns cleanup function. + * @deprecated - use watchEffect instead + */ + watchAll: (observer: Observer) => () => void; + /** Watch stock value. Returns cleanup function. Calls observer instantly. */ + watchEffect: (path: Pxth, observer: Observer) => () => void; + /** Check if value is observed or not. */ + isObserved: (path: Pxth) => boolean; + /** Notify all observers, which are children of specified path */ + notifySubTree: (path: Pxth, values: T) => void; + /** Notify all observers */ + notifyAll: (values: T) => void; + /** "stocked" updates values in batches, so you can subscribe to batch updates. Returns cleanup. */ + watchBatchUpdates: (observer: Observer>) => () => void; +}; + +/** Hook, wraps functionality of observers storage (add, remove, notify tree of observers, etc.) */ +export const useObservers = (values: MutableRefObject): ObserversControl => { + const observersMap = useRef>>(new PxthMap()); + const batchUpdateObservers = useLazyRef>>(() => new ObserverArray()); + + const batchUpdate = useCallback( + (update: BatchUpdate) => { + batchUpdateObservers.current.call(update); + }, + [batchUpdateObservers], + ); + + const observeBatchUpdates = useCallback( + (observer: Observer>) => batchUpdateObservers.current.add(observer), + [batchUpdateObservers], + ); + + const stopObservingBatchUpdates = useCallback( + (key: ObserverKey) => batchUpdateObservers.current.remove(key), + [batchUpdateObservers], + ); + + const observe = useCallback((path: Pxth, observer: Observer) => { + if (!observersMap.current.has(path)) { + observersMap.current.set(path, new ObserverArray()); + } + + return observersMap.current.get(path)!.add(observer as Observer); + }, []); + + const stopObserving = useCallback((path: Pxth, observerKey: ObserverKey) => { + const currentObservers = observersMap.current.get(path); + + invariant(currentObservers, 'Cannot remove observer from value, which is not observing'); + + currentObservers.remove(observerKey); + + if (currentObservers.isEmpty()) { + observersMap.current.remove(path); + } + }, []); + + const watch = useCallback( + (path: Pxth, observer: Observer) => { + const key = observe(path, observer); + return () => stopObserving(path, key); + }, + [observe, stopObserving], + ); + + const watchAll = useCallback((observer: Observer) => watch(createPxth([]), observer), [watch]); + + const watchEffect = useCallback( + (path: Pxth, observer: Observer) => { + observer(deepGet(values.current, path)); + const key = observe(path, observer); + return () => stopObserving(path, key); + }, + [observe, stopObserving, values], + ); + + const watchBatchUpdates = useCallback( + (observer: Observer>) => { + const key = observeBatchUpdates(observer); + + return () => stopObservingBatchUpdates(key); + }, + [observeBatchUpdates, stopObservingBatchUpdates], + ); + + const isObserved = useCallback((path: Pxth) => observersMap.current.has(path), []); + + const notifyPaths = useCallback( + (origin: Pxth, paths: Pxth[], values: T) => { + batchUpdate({ paths, origin, values }); + paths.forEach((path) => { + const observer = observersMap.current.get(path); + if (observer) { + const subValue = deepGet(values, path); + observer.call(subValue); + } + }); + }, + [batchUpdate], + ); + + const notifySubTree = useCallback( + (path: Pxth, values: T) => { + const subPaths = observersMap.current + .keys() + .filter( + (tempPath) => + isInnerPxth(path as Pxth, tempPath) || + samePxth(path as Pxth, tempPath) || + isInnerPxth(tempPath, path as Pxth), + ); + + notifyPaths(path as Pxth, subPaths, values); + }, + [notifyPaths], + ); + + const notifyAll = useCallback( + (values: T) => notifyPaths(createPxth([]), observersMap.current.keys(), values), + [notifyPaths], + ); + + return { + watch, + watchAll, + watchEffect, + watchBatchUpdates, + isObserved, + notifySubTree, + notifyAll, + }; +}; diff --git a/packages/stocked/src/hooks/useStock.ts b/packages/stocked/src/hooks/useStock.ts new file mode 100644 index 00000000..0df86f5d --- /dev/null +++ b/packages/stocked/src/hooks/useStock.ts @@ -0,0 +1,106 @@ +import { SetStateAction, useCallback, useMemo } from 'react'; +import cloneDeep from 'lodash/cloneDeep'; +import isFunction from 'lodash/isFunction'; +import { createPxth, deepGet, deepSet, Pxth } from 'pxth'; + +import { useDebugStock } from './useDebugStock'; +import { ObserversControl, useObservers } from './useObservers'; +import { useLazyRef } from '../utils/useLazyRef'; + +export type Stock = { + /** Function for setting value. Deeply sets value, using path to variable. @see https://lodash.com/docs/4.17.15#set */ + setValue: (path: Pxth, value: SetStateAction) => void; + /** Function for setting all values. */ + setValues: (values: T) => void; + /** Get actual value from stock. */ + getValue: (path: Pxth) => V; + /** Get all values from stock */ + getValues: () => T; + /** Function for resetting values to initial state */ + resetValues: () => void; + /** Paths to all variables */ + paths: Pxth; + /** Name, which appears in stocked devtools */ + debugName?: string; +} & Omit, 'notifyAll' | 'notifySubTree'>; + +export type StockConfig = { + initialValues: T; + debugName?: string; +}; + +/** + * Creates stock. + * + * Use it only if you want to use several Stock's at the same time. + * + * Instead, use `` component + * + * @param config - configuration of Stock. + */ +export const useStock = ({ initialValues, debugName }: StockConfig): Stock => { + const values = useLazyRef(() => cloneDeep(initialValues)); + const { notifySubTree, notifyAll, watch, watchAll, watchEffect, watchBatchUpdates, isObserved } = + useObservers(values); + + const setValue = useCallback( + (path: Pxth, action: SetStateAction) => { + // path = normalizePath(path as string); + + const value = isFunction(action) ? action(deepGet(values.current, path)) : action; + + values.current = deepSet(values.current, path, value) as T; + + notifySubTree(path, values.current); + }, + [values, notifySubTree], + ); + + const setValues = useCallback( + (newValues: T) => { + values.current = newValues; + notifyAll(newValues); + }, + [values, notifyAll], + ); + + const getValue = useCallback((path: Pxth) => deepGet(values.current, path) as V, [values]); + + const getValues = useCallback(() => values.current, [values]); + + const resetValues = useCallback(() => setValues(cloneDeep(initialValues)), [initialValues, setValues]); + + const stock: Stock = useMemo( + () => ({ + getValue, + getValues, + setValue, + setValues, + resetValues, + watch, + watchAll, + watchEffect, + watchBatchUpdates, + isObserved, + debugName, + paths: createPxth([]), + }), + [ + getValue, + getValues, + setValue, + setValues, + resetValues, + watch, + watchAll, + watchEffect, + watchBatchUpdates, + isObserved, + debugName, + ], + ); + + useDebugStock(stock); + + return stock; +}; diff --git a/packages/stocked/src/hooks/useStockContext.ts b/packages/stocked/src/hooks/useStockContext.ts new file mode 100644 index 00000000..291dcab5 --- /dev/null +++ b/packages/stocked/src/hooks/useStockContext.ts @@ -0,0 +1,25 @@ +import { useContext } from 'react'; +import invariant from 'tiny-invariant'; + +import { Stock } from './useStock'; +import { StockContext } from '../components'; +import { ProxyContext } from '../components/ProxyContext'; +import { StockProxy } from '../typings'; +import { useInterceptors } from '../utils/useInterceptors'; + +/** + * Function to access stock, with automatically applying proxy. By default, will pick stock and proxy from context. + * @param stock - optional argument. Pass it if you don't want to use stock from context. + * @param proxy - optional argument. Pass it if you don't want to use proxy from context. + */ +export const useStockContext = (stock?: Stock, proxy?: StockProxy): Stock => { + const contextStock = useContext(StockContext) as Stock | undefined; + const contextProxy = useContext(ProxyContext); + + stock = stock ?? contextStock; + proxy = proxy ?? contextProxy; + + invariant(stock, "You're trying to access stock outside StockContext and without providing custom stock."); + + return useInterceptors(stock, proxy); +}; diff --git a/packages/stocked/src/hooks/useStockState.ts b/packages/stocked/src/hooks/useStockState.ts new file mode 100644 index 00000000..81cfdbaa --- /dev/null +++ b/packages/stocked/src/hooks/useStockState.ts @@ -0,0 +1,32 @@ +import { Dispatch, SetStateAction, useCallback } from 'react'; +import { Pxth } from 'pxth'; + +import { Stock } from './useStock'; +import { useStockContext } from './useStockContext'; +import { useStockValue } from './useStockValue'; +import { StockProxy } from '../typings'; + +/** + * Hook, returns tuple of value and value set action. + * Returns *actual* value. + * This means, this hook fires re-render each time value in stock was changed. + * Similar to standard React's `useState` hook. + * @param path - path to variable in stock, deeply gets value. @see https://lodash.com/docs/4.17.15#get + * @param customStock - optional parameter, if you want to work with custom stock, not received from context. @see useStockContext + * @param proxy - optional parameter, if you want to pass custom proxy, not receive it from context. @see useStockContext + */ +export const useStockState = ( + path: Pxth, + customStock?: Stock, + proxy?: StockProxy, +): [V, Dispatch>] => { + const stock = useStockContext(customStock, proxy); + + const value = useStockValue(path, customStock, proxy); + + const { setValue } = stock; + + const set = useCallback((action: SetStateAction) => setValue(path, action), [path, setValue]); + + return [value, set]; +}; diff --git a/packages/stocked/src/hooks/useStockValue.ts b/packages/stocked/src/hooks/useStockValue.ts new file mode 100644 index 00000000..856fa85c --- /dev/null +++ b/packages/stocked/src/hooks/useStockValue.ts @@ -0,0 +1,39 @@ +import { useEffect, useReducer } from 'react'; +import { Pxth } from 'pxth'; + +import { Stock } from './useStock'; +import { useStockContext } from './useStockContext'; +import { StockProxy } from '../typings'; +import { useLazyRef } from '../utils/useLazyRef'; + +/** + * Hook, which returns *actual* stock value. + * This means, it will update component each time when value in stock changes. + * @param path - path to variable in stock, deeply gets value. @see https://lodash.com/docs/4.17.15#get + * @param customStock - optional parameter, if you want to work with custom stock, not received from context. @see useStockContext + * @param proxy - optional parameter, if you want to pass custom proxy, not receive it from context. @see useStockContext + */ +export const useStockValue = ( + path: Pxth, + customStock?: Stock, + proxy?: StockProxy, +): V => { + const stock = useStockContext(customStock, proxy); + + const { watchEffect, getValue } = stock; + + const [, forceUpdate] = useReducer((val) => val + 1, 0); + + const value = useLazyRef(() => getValue(path)); + + useEffect( + () => + watchEffect(path, (newValue) => { + value.current = newValue; + forceUpdate(); + }), + [path, watchEffect, value], + ); + + return value.current; +}; diff --git a/packages/stocked/src/index.ts b/packages/stocked/src/index.ts new file mode 100644 index 00000000..71f0cbdc --- /dev/null +++ b/packages/stocked/src/index.ts @@ -0,0 +1,6 @@ +export * from './hooks'; +export * from './typings'; +export * from './components'; +export * from './utils/ObserverArray'; + +export { intercept } from './utils/useInterceptors'; diff --git a/packages/stocked/src/typings/BatchUpdate.ts b/packages/stocked/src/typings/BatchUpdate.ts new file mode 100644 index 00000000..ac12f6ef --- /dev/null +++ b/packages/stocked/src/typings/BatchUpdate.ts @@ -0,0 +1,11 @@ +import { Pxth } from 'pxth'; + +/** Object, in which "stocked" calls observers */ +export type BatchUpdate = { + /** which paths should be updated */ + paths: Pxth[]; + /** path, which triggered subtree update */ + origin: Pxth; + /** all values, which should be sent to observers */ + values: T; +}; diff --git a/packages/stocked/src/typings/MappingProxy.ts b/packages/stocked/src/typings/MappingProxy.ts new file mode 100644 index 00000000..1f72e8bb --- /dev/null +++ b/packages/stocked/src/typings/MappingProxy.ts @@ -0,0 +1,143 @@ +import { SetStateAction } from 'react'; +import isFunction from 'lodash/isFunction'; +import isNil from 'lodash/isNil'; +import { deepGet, deepSet, isInnerPxth, joinPxths, longestCommonPxth, Pxth, relativePxth, samePxth } from 'pxth'; +import invariant from 'tiny-invariant'; + +import { Observer } from './Observer'; +import { PxthMap } from './PxthMap'; +import { StockProxy } from './StockProxy'; +import { ProxyMapSource } from '.'; +import { createProxyMap } from '../utils/createProxyMap'; +import { getInnerPaths, hasMappedParentPaths } from '../utils/mappingProxyUtils'; + +/** + * Simple example of StockProxy. + * Proxies values by map. Map is built by this method: + * { + * a: { + * b: { + * c: "" + * }, + * } + * } + */ +export class MappingProxy extends StockProxy { + private readonly proxyMap: PxthMap>; + + public constructor(mapSource: ProxyMapSource, path: Pxth) { + super(path); + this.proxyMap = createProxyMap(mapSource); + } + + public setValue = ( + path: Pxth, + value: SetStateAction, + defaultSetValue: (path: Pxth, value: SetStateAction) => void, + defaultGetValue: (path: Pxth) => U, + ) => { + const relativeValuePath = relativePxth(this.path as Pxth, path as Pxth); + const normalPath = this.getNormalPath(path); + + if (hasMappedParentPaths(relativeValuePath, this.proxyMap)) { + defaultSetValue(normalPath, value); + return; + } + + const innerPaths = getInnerPaths(relativeValuePath, this.proxyMap); + + const oldValue = defaultGetValue(normalPath); + + innerPaths.forEach( + ([to, from]) => + from !== undefined && + defaultSetValue( + from, + deepGet(isFunction(value) ? value(oldValue) : value, relativePxth(relativeValuePath, to)), + ), + ); + }; + + public watch = ( + path: Pxth, + observer: Observer, + defaultWatch: (path: Pxth, observer: Observer) => () => void, + ) => { + const normalPath = this.getNormalPath(path); + return defaultWatch(normalPath, (value) => observer(this.mapValue(value, path, normalPath) as V)); + }; + + public watchEffect = ( + path: Pxth, + observer: Observer, + defaultWatchEffect: (path: Pxth, observer: Observer) => () => void, + ) => { + const normalPath = this.getNormalPath(path); + return defaultWatchEffect(normalPath, (value) => observer(this.mapValue(value, path, normalPath) as V)); + }; + + public getValue = (path: Pxth, defaultGetValue: (path: Pxth) => U): V => { + const normalPath = this.getNormalPath(path); + return this.mapValue(defaultGetValue(normalPath), path, normalPath) as V; + }; + + private mapValue = (value: V, path: Pxth, normalPath: Pxth): V => { + path = relativePxth(this.path as Pxth, path as Pxth) as Pxth; + + if (hasMappedParentPaths(path, this.proxyMap)) { + return value; + } + + const innerPaths = getInnerPaths(path, this.proxyMap); + + return innerPaths.reduce( + (acc, [to, from]) => + deepSet( + acc as unknown as object, + relativePxth(path as Pxth, to), + deepGet(value, relativePxth(normalPath as Pxth, from!)), + ) as V, + {} as V, + ); + }; + + public getProxiedPath = (path: Pxth): Pxth => { + const normalPath = this.proxyMap.entries().find(([, from]) => samePxth(from, path as Pxth))?.[0]; + + invariant( + !isNil(normalPath), + 'Mapping proxy error: trying to get normal path of proxied path, which is not defined in proxy map', + ); + + return joinPxths(this.path as Pxth, normalPath) as Pxth; + }; + + public getNormalPath = (path: Pxth): Pxth => { + const normalPath = relativePxth(this.path as Pxth, path as Pxth); + + const isIndependent = this.proxyMap.has(normalPath); + + if (isIndependent) { + return this.proxyMap.get(normalPath) as Pxth; + } + + const hasMappedChildrenPaths = this.proxyMap.keys().some((mappedPath) => isInnerPxth(normalPath, mappedPath)); + + if (hasMappedChildrenPaths) { + return longestCommonPxth( + this.proxyMap + .entries() + .filter(([to]) => isInnerPxth(normalPath, to)) + .map(([, from]) => from), + ) as Pxth; + } + + if (hasMappedParentPaths(normalPath, this.proxyMap)) { + const [to, from] = this.proxyMap.entries().find(([mappedPath]) => isInnerPxth(mappedPath, normalPath))!; + + return joinPxths(from!, relativePxth(to, normalPath)) as Pxth; + } + + invariant(false, 'Mapping proxy error: trying to proxy value, which is not defined in proxy map.'); + }; +} diff --git a/packages/stocked/src/typings/Observer.ts b/packages/stocked/src/typings/Observer.ts new file mode 100644 index 00000000..20f689f4 --- /dev/null +++ b/packages/stocked/src/typings/Observer.ts @@ -0,0 +1 @@ +export type Observer = (message: V) => void; diff --git a/packages/stocked/src/typings/ProxyMapSource.ts b/packages/stocked/src/typings/ProxyMapSource.ts new file mode 100644 index 00000000..77f92137 --- /dev/null +++ b/packages/stocked/src/typings/ProxyMapSource.ts @@ -0,0 +1,9 @@ +import { Pxth } from 'pxth'; + +type Primitive = string | number | boolean | bigint | symbol | null | undefined; + +type ObjectMappingType = { + [P in keyof T]: ProxyMapSource; +}; + +export type ProxyMapSource = T extends Primitive ? Pxth : ObjectMappingType | Pxth; diff --git a/packages/stocked/src/typings/PxthMap.ts b/packages/stocked/src/typings/PxthMap.ts new file mode 100644 index 00000000..f7a7078f --- /dev/null +++ b/packages/stocked/src/typings/PxthMap.ts @@ -0,0 +1,33 @@ +import { Pxth } from 'pxth'; + +import { hashPxth } from '../utils/hashPxth'; + +export class PxthMap { + private _values: Record = {}; + private _keys: Record> = {}; + + public get = (key: Pxth): Value | undefined => { + return this._values[hashPxth(key)]; + }; + + public set = (key: Pxth, value: Value) => { + const stingifiedKey = hashPxth(key); + this._values[stingifiedKey] = value; + this._keys[stingifiedKey] = key as Pxth; + }; + + public remove = (key: Pxth) => { + const stingifiedKey = hashPxth(key); + delete this._values[stingifiedKey]; + delete this._keys[stingifiedKey]; + }; + + public has = (key: Pxth) => { + return hashPxth(key) in this._values; + }; + + public keys = (): Pxth[] => Object.values(this._keys); + + public entries = (): Array<[key: Pxth, value: Value]> => + Object.entries(this._keys).map(([key, value]) => [value, this._values[key]]); +} diff --git a/packages/stocked/src/typings/StockProxy.ts b/packages/stocked/src/typings/StockProxy.ts new file mode 100644 index 00000000..01196b32 --- /dev/null +++ b/packages/stocked/src/typings/StockProxy.ts @@ -0,0 +1,57 @@ +import { SetStateAction } from 'react'; +import { Pxth } from 'pxth'; + +import { Observer } from './Observer'; + +/** + * Abstract class of "stocked" proxy + * By inheriting this class, you can provide custom logic for proxing (casting) values. + */ +export abstract class StockProxy { + /** Path to variable, where proxy is attached. */ + public readonly path: Pxth; + + public constructor(path: Pxth) { + this.path = path; + } + + /** Function, which sets proxied value. It will be callen only if proxied value is changing. */ + public abstract setValue: ( + path: Pxth, + value: SetStateAction, + defaultSetValue: (path: Pxth, value: SetStateAction) => void, + defaultGetValue: (path: Pxth) => U, + ) => void; + + /** + * Function for watching proxied value. Should return cleanup. + * @deprecated + */ + public abstract watch: ( + path: Pxth, + observer: Observer, + defaultWatch: (path: Pxth, observer: Observer) => () => void, + ) => () => void; + + /** Function for watching proxied value. Should return cleanup. Calls observer instantly. */ + public abstract watchEffect: ( + path: Pxth, + observer: Observer, + defaultWatchEffect: (path: Pxth, observer: Observer) => () => void, + ) => () => void; + + /** Function to access proxied value. */ + public abstract getValue: (path: Pxth, defaultGetValue: (path: Pxth) => U) => V; + + /** Function for getting proxied path from normal path. */ + public abstract getProxiedPath: (path: Pxth) => Pxth; + + /** Function for getting normal path from proxied path */ + public abstract getNormalPath: (path: Pxth) => Pxth; + + /** Activate proxy. After activation, you cannot modify proxy. */ + public activate = () => Object.freeze(this); + + /** Returns boolean, is proxy active and ready for use or not. */ + public isActive = () => Object.isFrozen(this); +} diff --git a/packages/stocked/src/typings/index.ts b/packages/stocked/src/typings/index.ts new file mode 100644 index 00000000..7492d791 --- /dev/null +++ b/packages/stocked/src/typings/index.ts @@ -0,0 +1,6 @@ +export * from './BatchUpdate'; +export * from './Observer'; +export * from './MappingProxy'; +export * from './StockProxy'; +export * from './ProxyMapSource'; +export * from './PxthMap'; diff --git a/packages/stocked/src/utils/ObserverArray.ts b/packages/stocked/src/utils/ObserverArray.ts new file mode 100644 index 00000000..8381e191 --- /dev/null +++ b/packages/stocked/src/utils/ObserverArray.ts @@ -0,0 +1,45 @@ +import invariant from 'tiny-invariant'; + +import { Observer } from '../typings/Observer'; + +export type ObserverKey = number; + +export class ObserverArray { + private readonly observers: Record> = {}; + private counter = 0; + + /** + * Calls all observers in the array. + * @param message - message, which would be sent to all observers + */ + public call(message: V) { + Object.values(this.observers).forEach((observer) => observer(message)); + } + + /** + * Registers new observer and returns key, which will be used for removing observer. + * @param observer - registers new observer + */ + public add(observer: Observer): ObserverKey { + const key = this.counter++; + this.observers[key] = observer; + return key; + } + + /** + * Removes observer from array. Throws an error, if observer with that key not exists. + * @param key - key to observer + */ + public remove(key: ObserverKey) { + invariant( + Object.prototype.hasOwnProperty.call(this.observers, key), + `Could not remove observer: observer with key ${key} not exists`, + ); + delete this.observers[key]; + } + + /** + * Does array include at least one observer or not. + */ + public isEmpty = () => Object.values(this.observers).length === 0; +} diff --git a/packages/stocked/src/utils/areProxyMapsEqual.ts b/packages/stocked/src/utils/areProxyMapsEqual.ts new file mode 100644 index 00000000..37eec298 --- /dev/null +++ b/packages/stocked/src/utils/areProxyMapsEqual.ts @@ -0,0 +1,22 @@ +import { samePxth } from 'pxth'; + +import { createProxyMap } from './createProxyMap'; +import { ProxyMapSource } from '../typings/ProxyMapSource'; + +export const areProxyMapsEqual = (map1: ProxyMapSource, map2: ProxyMapSource) => { + const proxyMap1 = createProxyMap(map1); + const proxyMap2 = createProxyMap(map2); + + if (proxyMap1.entries().length !== proxyMap2.entries().length) { + return false; + } + + for (const [key, value] of proxyMap1.entries()) { + const value2 = proxyMap2.get(key); + if (!proxyMap2.has(key) || !samePxth(value, value2!)) { + return false; + } + } + + return true; +}; diff --git a/packages/stocked/src/utils/createProxyMap.ts b/packages/stocked/src/utils/createProxyMap.ts new file mode 100644 index 00000000..73a27486 --- /dev/null +++ b/packages/stocked/src/utils/createProxyMap.ts @@ -0,0 +1,44 @@ +import { createPxth, isPxth, joinPxths, Pxth } from 'pxth'; +import invariant from 'tiny-invariant'; + +import { ProxyMapSource } from '../typings/ProxyMapSource'; +import { PxthMap } from '../typings/PxthMap'; + +const getAllObjectKeys = (obj: object) => { + if (Array.isArray(obj)) { + return Object.keys(obj); + } + + return [...Object.getOwnPropertyNames(obj), ...Object.getOwnPropertySymbols(obj)]; +}; + +export const createProxyMap = (mapSource: ProxyMapSource) => { + const proxyMap = new PxthMap>(); + + if (isPxth(mapSource)) { + proxyMap.set(createPxth([]), mapSource); + return proxyMap; + } + + const queue: Array<[key: Pxth, value: Record]> = [[createPxth([]), mapSource]]; + + while (queue.length) { + const [pathToObject, innerObject] = queue.shift()!; + + for (const key of getAllObjectKeys(innerObject)) { + const item = innerObject[key] as Pxth | ProxyMapSource; + + const pathToItem = joinPxths(pathToObject, createPxth([key])); + + if (isPxth(item)) { + proxyMap.set(pathToItem, item); + } else if (typeof item === 'object' && item !== null) { + queue.push([pathToItem, item as Record]); + } else { + invariant(false, 'Invalid proxy map passed.'); + } + } + } + + return proxyMap; +}; diff --git a/packages/stocked/src/utils/hashPxth.ts b/packages/stocked/src/utils/hashPxth.ts new file mode 100644 index 00000000..9af6d108 --- /dev/null +++ b/packages/stocked/src/utils/hashPxth.ts @@ -0,0 +1,3 @@ +import { getPxthSegments, Pxth } from 'pxth'; + +export const hashPxth = (pxth: Pxth) => JSON.stringify(getPxthSegments(pxth)); diff --git a/packages/stocked/src/utils/mappingProxyUtils.ts b/packages/stocked/src/utils/mappingProxyUtils.ts new file mode 100644 index 00000000..685dcf95 --- /dev/null +++ b/packages/stocked/src/utils/mappingProxyUtils.ts @@ -0,0 +1,13 @@ +import { isInnerPxth, Pxth, samePxth } from 'pxth'; + +import { PxthMap } from '../typings/PxthMap'; + +export const getInnerPaths = (path: Pxth, proxyMap: PxthMap>) => { + return proxyMap.entries().filter(([to]) => { + return isInnerPxth(path as Pxth, to) || samePxth(path as Pxth, to); + }); +}; + +export const hasMappedParentPaths = (path: Pxth, proxyMap: PxthMap>) => { + return proxyMap.entries().some(([mappedPath]) => isInnerPxth(mappedPath, path as Pxth)); +}; diff --git a/packages/stocked/src/utils/useInterceptors.ts b/packages/stocked/src/utils/useInterceptors.ts new file mode 100644 index 00000000..bd4bd254 --- /dev/null +++ b/packages/stocked/src/utils/useInterceptors.ts @@ -0,0 +1,135 @@ +import { SetStateAction, useCallback, useEffect } from 'react'; +import cloneDeep from 'lodash/cloneDeep'; +import isFunction from 'lodash/isFunction'; +import unset from 'lodash/unset'; +import { deepGet, deepSet, getPxthSegments, isInnerPxth, Pxth, samePxth } from 'pxth'; +import invariant from 'tiny-invariant'; + +import { Stock } from '../hooks/useStock'; +import { Observer } from '../typings'; +import { StockProxy } from '../typings/StockProxy'; + +const shouldUseProxy = (proxy: StockProxy | undefined, path: Pxth) => + proxy && (isInnerPxth(proxy.path, path) || samePxth(proxy.path, path)); + +/** + * Helper function. Calls `standardCallback` if `proxy` is undefined, or if `path` isn't inner path of `proxy.path` variable. + * Otherwise, calls `proxiedCallback`. + * Passes args into function. + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +export const intercept = any>( + proxy: StockProxy | undefined, + path: Pxth, + standardCallback: T, + proxiedCallback: T, + args: Parameters, +): ReturnType => { + if (!shouldUseProxy(proxy, path)) { + return standardCallback(...args); + } else { + return proxiedCallback(...args); + } +}; + +/** Intercepts stock's `observe`, `stopObserving` and `setValue` functions, if proxy is provided. */ +export const useInterceptors = (stock: Stock, proxy?: StockProxy): Stock => { + const { watch, watchEffect, setValue, getValue, setValues, getValues } = stock; + + useEffect( + () => + invariant( + !proxy || proxy.isActive(), + 'Cannot use not activated proxy. Maybe you forgot to call proxy.activate()?', + ), + [proxy], + ); + + const interceptedWatch = useCallback( + (path: Pxth, observer: Observer) => + intercept( + proxy, + path as Pxth, + watch, + (path: Pxth, observer: Observer) => proxy!.watch(path, observer, watch), + [path, observer], + ), + [watch, proxy], + ); + + const interceptedWatchEffect = useCallback( + (path: Pxth, observer: Observer) => + intercept( + proxy, + path as Pxth, + watchEffect, + (path: Pxth, observer: Observer) => proxy!.watchEffect(path, observer, watchEffect), + [path, observer], + ), + [watchEffect, proxy], + ); + + const interceptedSetValue = useCallback( + (path: Pxth, value: SetStateAction) => + intercept( + proxy, + path as Pxth, + setValue, + (path: Pxth, value: SetStateAction) => proxy!.setValue(path, value, setValue, getValue), + [path as Pxth, value], + ), + [getValue, proxy, setValue], + ); + + const interceptedGetValue = useCallback( + (path: Pxth) => + intercept(proxy, path as Pxth, getValue, (path: Pxth) => proxy!.getValue(path, getValue), [ + path, + ]), + [proxy, getValue], + ); + + const interceptedGetValues = useCallback(() => { + let allValues = cloneDeep(getValues()); + + const proxiedValue = proxy!.getValue(proxy!.path, getValue); + + allValues = deepSet(allValues, proxy!.path, proxiedValue) as T; + + return allValues; + }, [proxy, getValues, getValue]); + + const interceptedSetValues = useCallback( + (values: T) => { + const proxiedValue = deepGet(values, proxy!.path); + + unset(values, getPxthSegments(proxy!.path)); + + proxy!.setValue( + proxy!.path, + proxiedValue, + (path, value) => { + values = deepSet(values, path, isFunction(value) ? value(deepGet(values, path)) : value) as T; + }, + getValue, + ); + + setValues(values); + }, + [getValue, proxy, setValues], + ); + + if (!proxy) { + return stock; + } + + return { + ...stock, + watch: interceptedWatch, + watchEffect: interceptedWatchEffect, + setValue: interceptedSetValue, + getValue: interceptedGetValue, + getValues: interceptedGetValues, + setValues: interceptedSetValues, + }; +}; diff --git a/packages/stocked/src/utils/useLazyRef.ts b/packages/stocked/src/utils/useLazyRef.ts new file mode 100644 index 00000000..0054507a --- /dev/null +++ b/packages/stocked/src/utils/useLazyRef.ts @@ -0,0 +1,15 @@ +import { MutableRefObject, useRef } from 'react'; + +/** + * Same as `React.useRef` but with lazy initialization. + * @param initializer - function, which initializes value. Called once. + */ +export const useLazyRef = (initializer: () => T): MutableRefObject => { + const ref = useRef(null); + + if (ref.current === null) { + ref.current = initializer(); + } + + return ref as MutableRefObject; +}; diff --git a/packages/stocked/test/.eslintrc b/packages/stocked/test/.eslintrc new file mode 100644 index 00000000..e34fb1f8 --- /dev/null +++ b/packages/stocked/test/.eslintrc @@ -0,0 +1,9 @@ +{ + "env": { + "jest": true + }, + "rules": { + "@typescript-eslint/no-empty-function": "off", + "@typescript-eslint/no-explicit-any": "off" + } +} diff --git a/packages/stocked/test/DummyProxy.ts b/packages/stocked/test/DummyProxy.ts new file mode 100644 index 00000000..47efc015 --- /dev/null +++ b/packages/stocked/test/DummyProxy.ts @@ -0,0 +1,12 @@ +import { Pxth } from 'pxth'; + +import { StockProxy } from '../src/typings/StockProxy'; + +export class DummyProxy extends StockProxy { + public getProxiedPath = (path: Pxth) => path; + public getNormalPath = (path: Pxth) => path; + public setValue = () => {}; + public watch = () => () => {}; + public watchEffect = () => () => {}; + public getValue = (path: Pxth, defaultGetValue: (path: Pxth) => U) => defaultGetValue(path) as V; +} diff --git a/packages/stocked/test/components/ProxyProvider.test.tsx b/packages/stocked/test/components/ProxyProvider.test.tsx new file mode 100644 index 00000000..19874ec0 --- /dev/null +++ b/packages/stocked/test/components/ProxyProvider.test.tsx @@ -0,0 +1,80 @@ +import React from 'react'; +import { render } from '@testing-library/react'; +import { createPxth } from 'pxth'; +import { describe, expect, it } from 'vitest'; + +import { MappingProxy, ProxyProvider, Stock, StockRoot, useStockContext } from '../../src'; + +const StockExtractor = ({ extract }: { extract: (stock: Stock) => void }) => { + const stock = useStockContext(); + + extract(stock); + + return
; +}; + +describe('ProxyProvider', () => { + it('should provide proxy', () => { + const proxy = new MappingProxy( + { + surname: createPxth(['user', 'name']), + }, + createPxth(['user']), + ); + + proxy.activate(); + + let stock: Stock | undefined = undefined; + + render( + + + (stock = value)} /> + + , + ); + + expect(stock!.getValue(createPxth(['user']))).toStrictEqual({ + surname: 'hello', + }); + }); + + it('should handle nested proxies', () => { + const proxy = new MappingProxy( + { + surname: createPxth(['user', 'name']), + }, + createPxth(['user']), + ); + + const proxy2 = new MappingProxy( + { + name: { + surname: createPxth(['user', 'surname']), + }, + }, + createPxth(['user']), + ); + + proxy.activate(); + proxy2.activate(); + + let stock: Stock | undefined = undefined; + + render( + + + + (stock = value)} /> + + + , + ); + + expect(stock!.getValue(createPxth(['user']))).toStrictEqual({ + name: { + surname: 'hello', + }, + }); + }); +}); diff --git a/packages/stocked/test/components/StockRoot.test.tsx b/packages/stocked/test/components/StockRoot.test.tsx new file mode 100644 index 00000000..25fe83cf --- /dev/null +++ b/packages/stocked/test/components/StockRoot.test.tsx @@ -0,0 +1,80 @@ +import React from 'react'; +import { render } from '@testing-library/react'; +import { createPxth } from 'pxth'; +import { describe, expect, it, vi } from 'vitest'; + +import { Stock, StockRoot, useStockContext } from '../../src'; + +const StockExtractor = ({ + children, + logStock, +}: { + children?: React.ReactNode; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + logStock: (stock: Stock) => void; +}) => { + const stock = useStockContext(); + + logStock(stock); + + return
{children}
; +}; + +describe('StockRoot context testing', () => { + it('should pass clone of initialValues into context', () => { + const initialValues = { + hello: 'asdf', + parent: { + child: { + value: 'test', + }, + }, + array: [ + 0, + { + nested: 'value', + }, + ], + }; + + let realValues: object | undefined = undefined; + + render( + +
+

Test component

+

other component

+ (realValues = stock.getValues())} /> +
+ , + ); + + expect(realValues).toStrictEqual(initialValues); + }); +}); + +describe('StockRoot performance testing', () => { + it('should never rerender StockRoot', () => { + const RerenderCounter: React.FC = vi.fn(() =>
); + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let stock: Stock | undefined = undefined; + + render( + + + (stock = _stock)} /> + , + ); + + if (stock) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const _stock = stock as any; + _stock.setValue(createPxth(['hello']), 'asdf'); + _stock.setValue(createPxth(['nested', 'value']), 3); + _stock.setValue(createPxth(['asdfasd', 'asdf', 'asdf']), 'asdf'); + } + + expect(RerenderCounter).toBeCalledTimes(1); + }); +}); diff --git a/packages/stocked/test/hooks/useAllStockValues.test.tsx b/packages/stocked/test/hooks/useAllStockValues.test.tsx new file mode 100644 index 00000000..d56036ac --- /dev/null +++ b/packages/stocked/test/hooks/useAllStockValues.test.tsx @@ -0,0 +1,83 @@ +import React, { PropsWithChildren } from 'react'; +import { act, renderHook, waitFor } from '@testing-library/react'; +import { createPxth } from 'pxth'; +import { beforeEach, describe, expect, it } from 'vitest'; + +import { Stock, StockContext, useAllStockValues, useStock } from '../../src'; + +const initialValues = { + hello: 'test', + parent: { + child: 'value', + }, + array: [ + 1, + { + value: 'second', + }, + ], +}; + +let stock: Stock; + +const wrapper = ({ children }: PropsWithChildren) => ( + }>{children} +); + +const renderUseStockValues = () => + renderHook(() => useAllStockValues(stock), { + wrapper, + }); + +beforeEach(() => { + const { result } = renderHook(() => useStock({ initialValues }), { wrapper }); + stock = result.current; +}); + +describe('Testing "useStockValues" with context stock', () => { + it('Should return new values after update using setValues', async () => { + const { result } = renderUseStockValues(); + + expect(result.current).toStrictEqual(initialValues); + + const newValue = { + hello: 'changed', + parent: { + child: 'changed', + }, + array: [ + 42, + { + value: 'changed', + }, + ], + }; + + act(() => { + stock.setValues(newValue); + }); + + await waitFor(() => expect(result.current).toStrictEqual(newValue)); + }); + + it('Should return new values after update using setValue', async () => { + const { result } = renderUseStockValues(); + expect(result.current).toStrictEqual(initialValues); + + const newValue = [1, 42]; + + act(() => { + stock.setValue(createPxth(['array']), newValue); + }); + + await waitFor(() => + expect(result.current).toStrictEqual({ + hello: 'test', + parent: { + child: 'value', + }, + array: [1, 42], + }), + ); + }); +}); diff --git a/packages/stocked/test/hooks/useMappingProxy.test.ts b/packages/stocked/test/hooks/useMappingProxy.test.ts new file mode 100644 index 00000000..2e4b6e4a --- /dev/null +++ b/packages/stocked/test/hooks/useMappingProxy.test.ts @@ -0,0 +1,54 @@ +import { renderHook } from '@testing-library/react'; +import { createPxth, Pxth } from 'pxth'; +import { describe, expect, it } from 'vitest'; + +import { ProxyMapSource, useMappingProxy } from '../../src'; + +const renderUseMappingProxyHook = (path: Pxth, map: ProxyMapSource) => + renderHook(({ path, map }) => useMappingProxy(map, path), { + initialProps: { + path, + map, + }, + }); + +describe('useMappingProxy', () => { + it('should return activated proxy', () => { + const { result } = renderUseMappingProxyHook(createPxth([]), {}); + + expect(result.current.isActive()).toBeTruthy(); + }); + + it('should return same mapping proxy, if argument values not changed', () => { + const { result, rerender } = renderUseMappingProxyHook(createPxth([]), { b: createPxth(['c']) }); + + const savedResult = result.current; + + rerender({ path: createPxth([]), map: { b: createPxth(['c']) } }); + + expect(savedResult).toBe(result.current); + }); + + it('should return new mapping proxy, when map changes', () => { + const { result, rerender } = renderUseMappingProxyHook(createPxth([]), { b: createPxth(['c']) }); + + const savedResult = result.current; + rerender({ path: createPxth([]), map: { b: createPxth(['d']) } }); + + expect(savedResult).not.toBe(result.current); + + const savedResult2 = result.current; + rerender({ path: createPxth([]), map: { b: createPxth(['d']) } }); + + expect(savedResult2).toBe(result.current); + }); + + it('should return new mapping proxy, when path changes', () => { + const { result, rerender } = renderUseMappingProxyHook(createPxth([]), { b: createPxth(['c']) }); + + const savedResult = result.current; + rerender({ path: createPxth(['a']), map: { b: createPxth(['c']) } }); + + expect(savedResult).not.toBe(result.current); + }); +}); diff --git a/packages/stocked/test/hooks/useObservers.test.ts b/packages/stocked/test/hooks/useObservers.test.ts new file mode 100644 index 00000000..37628b7b --- /dev/null +++ b/packages/stocked/test/hooks/useObservers.test.ts @@ -0,0 +1,311 @@ +import { act, renderHook } from '@testing-library/react'; +import { createPxth, getPxthSegments } from 'pxth'; +import { describe, expect, it, vi } from 'vitest'; + +import { useObservers } from '../../src'; + +const renderUseObserversHook = (values: object = {}) => + renderHook(() => + useObservers({ + current: values, + }), + ); + +describe('Observer tests', () => { + it('should call value observer', () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + + act(() => { + result.current.watch(createPxth(['b']), observer); + result.current.notifySubTree(createPxth(['b']), { + b: 0, + }); + }); + + expect(observer).toBeCalled(); + }); + + it('should call observer instantly with "watchEffect"', () => { + const { result } = renderUseObserversHook({ + b: 'hello', + }); + + const observer = vi.fn(); + + act(() => { + result.current.watchEffect(createPxth(['b']), observer); + }); + + expect(observer).toBeCalled(); + }); + + it('Should call all values observer', async () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + let cleanup: () => void = () => {}; + + act(() => { + cleanup = result.current.watchAll(observer); + result.current.notifySubTree(createPxth(['b']), { b: 0 }); + }); + + expect(observer).toBeCalled(); + expect(result.current.isObserved(createPxth([]))).toBe(true); + cleanup(); + expect(result.current.isObserved(createPxth([]))).toBe(false); + }); + + it('should call parent observer', () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + + act(() => { + result.current.watch(createPxth(['parent']), observer); + result.current.notifySubTree(createPxth(['parent', 'child']), { + parent: { + child: 0, + }, + }); + }); + + expect(observer).toBeCalled(); + }); + + it('should call child observer', () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + + act(() => { + result.current.watch(createPxth(['parent', 'child']), observer); + result.current.notifySubTree(createPxth(['parent']), { parent: { child: 'b' } }); + }); + + expect(observer).toBeCalled(); + }); + + it('should call tree branch of observers', () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + + act(() => { + result.current.watch(createPxth(['parent']), observer); + result.current.watch(createPxth(['parent', 'child']), observer); + result.current.watch(createPxth(['parent', 'child', 'value']), observer); + result.current.notifySubTree(createPxth(['parent', 'child', 'value']), { + parent: { + child: { + value: 'b', + }, + }, + }); + }); + + expect(observer).toBeCalledTimes(3); + }); + + it('should call all observers', () => { + const { result } = renderUseObserversHook(); + + const oberver = vi.fn(); + + act(() => { + result.current.watch(createPxth(['parent']), oberver); + result.current.watch(createPxth(['parent', 'child']), oberver); + result.current.watch(createPxth(['parent', 'child', 'value']), oberver); + result.current.notifyAll({ parent: { child: { value: 'b' } } }); + }); + + expect(oberver).toBeCalledTimes(3); + }); + + it("shouldn't call observer", () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + + act(() => { + result.current.watch(createPxth(['parent', 'notInBranch']), observer); + result.current.notifySubTree(createPxth(['parent', 'child', 'value']), { + parent: { + child: { + value: 'newValue', + }, + notInBranch: { + value: 'asdf', + }, + }, + }); + }); + + expect(observer).not.toBeCalled(); + }); + + it('should receive correct value', () => { + const { result } = renderUseObserversHook(); + + const value = 'hello'; + + const parentObserver = vi.fn(); + const childObserver = vi.fn(); + + act(() => { + result.current.watch(createPxth(['parent']), parentObserver); + result.current.watch(createPxth(['parent', 'child']), childObserver); + result.current.notifySubTree(createPxth(['parent', 'child']), { + parent: { + child: value, + }, + }); + }); + + expect(childObserver).toBeCalledWith(value); + expect(parentObserver).toBeCalledWith({ child: value }); + }); +}); + +describe('Is observed test', () => { + it('should be observed', () => { + const { result } = renderUseObserversHook(); + + act(() => { + result.current.watch(createPxth(['value']), vi.fn()); + }); + + expect(result.current.isObserved(createPxth(['value']))).toBeTruthy(); + expect(result.current.isObserved(createPxth(['asdf']))).toBeFalsy(); + }); + it('should be observed denormalized path', () => { + const { result } = renderUseObserversHook(); + + act(() => { + result.current.watch(createPxth(['arr', '0']), vi.fn()); + }); + + expect(result.current.isObserved(createPxth(['arr', '0']))).toBeTruthy(); + expect(result.current.isObserved(createPxth(['arr', '3']))).toBeFalsy(); + }); +}); + +describe('Removing observers test', () => { + it('should remove observer', () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + + act(() => { + const cleanup = result.current.watch(createPxth(['value']), observer); + + result.current.notifySubTree(createPxth(['value']), { value: '2' }); + + cleanup(); + + result.current.notifySubTree(createPxth(['value']), { value: '3' }); + }); + + expect(observer).toBeCalledTimes(1); + }); + + it('should remove denormalized path observer', () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + + act(() => { + const cleanup = result.current.watch(createPxth(['arr', '0']), observer); + + result.current.notifySubTree(createPxth(['arr', '0']), { arr: [0] }); + result.current.notifySubTree(createPxth(['arr', '0']), { arr: [1] }); + + cleanup(); + + result.current.notifySubTree(createPxth(['arr', '0']), { arr: [2] }); + result.current.notifySubTree(createPxth(['arr', '0']), { arr: [3] }); + }); + + expect(observer).toBeCalledTimes(2); + }); +}); + +describe('Batch observers tests', () => { + it('should call observer', () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + + act(() => { + result.current.watchBatchUpdates(observer); + + result.current.notifySubTree(createPxth(['value']), { + value: '2', + }); + }); + + expect(observer).toBeCalled(); + }); + + it('should call observer on any update with arguments', () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + + act(() => { + result.current.watchBatchUpdates(observer); + result.current.watch(createPxth(['parent', 'child']), vi.fn()); + result.current.watch(createPxth(['parent']), vi.fn()); + result.current.watch(createPxth(['value']), vi.fn()); + + result.current.notifySubTree(createPxth(['parent', 'child', 'hello']), { + value: 'asdf', + parent: { + child: { + hello: '2', + }, + }, + }); + }); + + expect(observer).toBeCalled(); + expect(getPxthSegments(observer.mock.calls[0][0].origin)).toStrictEqual(['parent', 'child', 'hello']); + expect(observer.mock.calls[0][0].paths.map(getPxthSegments)).toStrictEqual([['parent', 'child'], ['parent']]); + expect(observer).toBeCalledWith({ + origin: expect.anything(), + paths: expect.anything(), + values: { + value: 'asdf', + parent: { + child: { + hello: '2', + }, + }, + }, + }); + }); + + it('should remove observer', () => { + const { result } = renderUseObserversHook(); + + const observer = vi.fn(); + + act(() => { + const cleanup = result.current.watchBatchUpdates(observer); + + result.current.notifySubTree(createPxth(['value']), { + value: '2', + }); + + cleanup(); + + result.current.notifySubTree(createPxth(['value']), { + value: 'h', + }); + }); + + expect(observer).toBeCalledTimes(1); + }); +}); diff --git a/packages/stocked/test/hooks/useStock.test.ts b/packages/stocked/test/hooks/useStock.test.ts new file mode 100644 index 00000000..66b47445 --- /dev/null +++ b/packages/stocked/test/hooks/useStock.test.ts @@ -0,0 +1,294 @@ +import { act, renderHook } from '@testing-library/react'; +import { createPxth } from 'pxth'; +import { describe, expect, it, vi } from 'vitest'; + +import { StockConfig, useStock } from '../../src'; + +const renderUseStockHook = (initialValues: object) => + renderHook((props: StockConfig) => useStock(props), { + initialProps: { initialValues }, + }); + +describe('Value setting and getting', () => { + it('should not mutate initial values', () => { + const testDateValue = new Date(); + const initialValues = { + first: 'a', + second: 'b', + nested: { + value: 'c', + }, + array: [ + { + prop1: 15, + }, + { + prop2: testDateValue, + }, + ], + }; + + const { result } = renderUseStockHook(initialValues); + + act(() => { + result.current.setValue(createPxth(['first']), 'b'); + result.current.setValue(createPxth(['nested.value']), 'b'); + result.current.setValue(createPxth(['array[0].prop1']), 'b'); + }); + + expect(initialValues).toStrictEqual({ + first: 'a', + second: 'b', + nested: { + value: 'c', + }, + array: [ + { + prop1: 15, + }, + { + prop2: testDateValue, + }, + ], + }); + }); + + it('should set value', () => { + const { result } = renderUseStockHook({ + first: 'a', + second: 'b', + }); + + act(() => { + result.current.setValue(createPxth(['first']), 'test'); + }); + + expect(result.current.getValues()).toStrictEqual({ + first: 'test', + second: 'b', + }); + + act(() => { + result.current.setValue(createPxth(['second']), 0); + }); + + expect(result.current.getValues()).toStrictEqual({ + first: 'test', + second: 0, + }); + }); + + it('should set value via updater function', () => { + const { result } = renderUseStockHook({ + first: 'a', + second: { + third: 'b', + }, + }); + + act(() => { + result.current.setValue(createPxth(['first']), (prevValue: string) => prevValue + 'b'); + }); + + expect(result.current.getValues()).toStrictEqual({ + first: 'ab', + second: { + third: 'b', + }, + }); + + act(() => { + result.current.setValue(createPxth(['second']), (prevValue: object) => ({ ...prevValue, new: 5 })); + }); + + expect(result.current.getValues()).toStrictEqual({ + first: 'ab', + second: { + third: 'b', + new: 5, + }, + }); + }); + + it('should set nested value', () => { + const { result } = renderUseStockHook({ + nested: { + value: 'a', + second: { + value: 'b', + third: { + fourth: 'c', + }, + }, + }, + }); + + act(() => { + result.current.setValue(createPxth(['nested', 'value']), 'b'); + }); + + expect(result.current.getValues()).toStrictEqual({ + nested: { + value: 'b', + second: { + value: 'b', + third: { + fourth: 'c', + }, + }, + }, + }); + + act(() => { + result.current.setValue(createPxth(['nested', 'second', 'value']), 'c'); + }); + + expect(result.current.getValues()).toStrictEqual({ + nested: { + value: 'b', + second: { + value: 'c', + third: { + fourth: 'c', + }, + }, + }, + }); + + act(() => { + result.current.setValue(createPxth(['nested', 'second', 'third', 'fourth']), 'd'); + }); + + expect(result.current.getValues()).toStrictEqual({ + nested: { + value: 'b', + second: { + value: 'c', + third: { + fourth: 'd', + }, + }, + }, + }); + + act(() => { + result.current.setValue(createPxth(['nested', 'second']), { value: 'd', third: { fourth: 'e' } }); + }); + + expect(result.current.getValues()).toStrictEqual({ + nested: { + value: 'b', + second: { + value: 'd', + third: { + fourth: 'e', + }, + }, + }, + }); + }); + + it('should set array value', () => { + const { result } = renderUseStockHook({ + arr: [ + { + p1: 'a', + }, + { + p2: 'b', + }, + ], + }); + + act(() => { + result.current.setValue(createPxth(['arr', '0', 'p1']), 0); + }); + + expect(result.current.getValues()).toStrictEqual({ + arr: [ + { + p1: 0, + }, + { + p2: 'b', + }, + ], + }); + + act(() => { + result.current.setValue(createPxth(['arr', '1', 'p2']), null); + }); + + expect(result.current.getValues()).toStrictEqual({ + arr: [ + { + p1: 0, + }, + { + p2: null, + }, + ], + }); + }); + + it('should send array to observers', () => { + const { result } = renderUseStockHook({ + arr: ['val1', 'val2'], + }); + + const observer = vi.fn(); + + const newValues = ['val3', 'val4']; + + act(() => { + result.current.watch(createPxth(['arr']), observer); + result.current.setValue(createPxth(['arr']), newValues); + }); + + expect(observer.mock.calls[0][0]).toStrictEqual(newValues); + }); + + it('should set all values', () => { + const { result } = renderUseStockHook({}); + + act(() => { + result.current.setValues({ + hello: 'asdf', + b: { + c: 0, + }, + }); + }); + + expect(result.current.getValues()).toStrictEqual({ + hello: 'asdf', + b: { + c: 0, + }, + }); + }); + + it('should reset values to initial', () => { + const initialValues = { + first: 'a', + second: { + third: 'b', + }, + }; + + const observer = vi.fn(); + + const { result } = renderUseStockHook(initialValues); + + act(() => { + result.current.watch(createPxth(['second']), observer); + result.current.setValue(createPxth(['second']), { third: 'new' }); + result.current.resetValues(); + }); + + expect(result.current.getValues()).toStrictEqual(initialValues); + expect(observer.mock.calls[1][0]).toStrictEqual({ + third: 'b', + }); + }); +}); diff --git a/packages/stocked/test/hooks/useStockContext.test.tsx b/packages/stocked/test/hooks/useStockContext.test.tsx new file mode 100644 index 00000000..8f34b95c --- /dev/null +++ b/packages/stocked/test/hooks/useStockContext.test.tsx @@ -0,0 +1,99 @@ +import React, { PropsWithChildren } from 'react'; +import { act, renderHook } from '@testing-library/react'; +import { createPxth, getPxthSegments } from 'pxth'; +import { describe, expect, it, vi } from 'vitest'; + +import { StockContext, useStock, useStockContext } from '../../src'; +import { ProxyContext } from '../../src/components/ProxyContext'; +import { DummyProxy } from '../DummyProxy'; + +describe('Test "useStockContext" hook', () => { + it('should throw error', () => { + expect(() => renderHook(() => useStockContext())).toThrow(); + }); + + it('should return stock from context', () => { + const { + result: { current: stock }, + } = renderHook(() => useStock({ initialValues: {} })); + + const wrapper = ({ children }: PropsWithChildren) => ( + {children} + ); + + const { result } = renderHook(() => useStockContext(), { wrapper }); + + expect(result.current).toBe(stock); + }); + + it('should return stock from arguments', () => { + const { + result: { current: stock }, + } = renderHook(() => useStock({ initialValues: {} })); + + const { result } = renderHook(() => useStockContext(stock)); + + expect(result.current).toBe(stock); + }); + + it('should take proxy from context', () => { + const { + result: { current: stock }, + } = renderHook(() => useStock({ initialValues: {} })); + + const proxy = new DummyProxy(createPxth(['asdf'])); + + const watch = vi.fn(); + + proxy.watch = watch; + + proxy.activate(); + + const wrapper = ({ children }: PropsWithChildren) => ( + {children} + ); + + const { result } = renderHook(() => useStockContext(stock), { wrapper }); + + expect(result.current === stock).toBeFalsy(); + + const observer = vi.fn(); + + act(() => { + result.current.watch(createPxth(['asdf']), observer); + result.current.watch(createPxth(['aaaa']), () => {}); + }); + + expect(getPxthSegments(watch.mock.calls[watch.mock.calls.length - 1][0])).toStrictEqual(['asdf']); + + expect(watch).lastCalledWith(expect.anything(), observer, expect.any(Function)); + }); + + it('should take proxy from arguments', () => { + const { + result: { current: stock }, + } = renderHook(() => useStock({ initialValues: {} })); + + const proxy = new DummyProxy(createPxth(['asdf'])); + + const watch = vi.fn(); + + proxy.watch = watch; + + proxy.activate(); + + const { result } = renderHook(() => useStockContext(stock, proxy)); + + expect(result.current == stock).toBeFalsy(); + + const observer = vi.fn(); + + act(() => { + result.current.watch(createPxth(['asdf']), observer); + result.current.watch(createPxth(['aaaa']), () => {}); + }); + + expect(getPxthSegments(watch.mock.calls[watch.mock.calls.length - 1][0])).toStrictEqual(['asdf']); + expect(watch).lastCalledWith(expect.anything(), observer, expect.any(Function)); + }); +}); diff --git a/packages/stocked/test/hooks/useStockState.test.tsx b/packages/stocked/test/hooks/useStockState.test.tsx new file mode 100644 index 00000000..9c0f7ddb --- /dev/null +++ b/packages/stocked/test/hooks/useStockState.test.tsx @@ -0,0 +1,97 @@ +import React, { PropsWithChildren } from 'react'; +import { act, renderHook, waitFor } from '@testing-library/react'; +import { createPxth, Pxth } from 'pxth'; +import { beforeEach, describe, expect, it } from 'vitest'; + +import { Stock, StockContext, useStock, useStockState } from '../../src'; + +const initialValues = { + hello: 'test', + parent: { + child: 'value', + }, + value: 0, + array: [ + 1, + { + value: 'second', + }, + ], +}; + +let stock: Stock; + +const wrapper = ({ children }: PropsWithChildren) => ( + }>{children} +); + +const renderUseStockState = (path: Pxth, useContext = true) => + renderHook(() => useStockState(path, useContext ? undefined : stock), { + wrapper: useContext ? wrapper : undefined, + }); + +beforeEach(() => { + const { result } = renderHook(() => useStock({ initialValues }), { wrapper }); + stock = result.current; +}); + +const testWrapper = (testName: string, useContext: boolean) => { + describe(testName, () => { + it('Should set value via setter', async () => { + const { result } = renderUseStockState(createPxth(['parent', 'child']), useContext); + + const [, setValue] = result.current; + const newValue = 'newValue'; + + act(() => { + setValue(newValue); + }); + + await waitFor(() => expect(result.current[0]).toBe(newValue)); + }); + + it('Should set value via updater function', async () => { + const { result } = renderUseStockState(createPxth(['parent', 'child']), useContext); + + const [, setValue] = result.current; + + act(() => { + setValue(() => 'value_changed_via_updater'); + }); + + await waitFor(() => expect(result.current[0]).toBe('value_changed_via_updater')); + }); + + it('Value updater should receive actual value', async () => { + const { result } = renderUseStockState(createPxth(['value']), useContext); + + const [, setValue] = result.current; + const updater = (value: number) => ++value; + + act(() => { + setValue(updater); + setValue(updater); + setValue(updater); + }); + + await waitFor(() => expect(result.current[0]).toBe(3)); + }); + + it('Should update when externally set value', async () => { + const { result } = renderUseStockState(createPxth(['hello']), useContext); + + expect(result.current[0]).toBe(initialValues.hello); + + const newValue = 'newValue'; + + act(() => { + stock.setValue(createPxth(['hello']), newValue); + }); + + await waitFor(() => expect(result.current[0]).toBe(newValue)); + }); + }); +}; + +testWrapper('Testing "useStockState" with context stock', true); +testWrapper('Testing "useStockState" with provided into arguments stock', false); diff --git a/packages/stocked/test/hooks/useStockValue.test.tsx b/packages/stocked/test/hooks/useStockValue.test.tsx new file mode 100644 index 00000000..806258d1 --- /dev/null +++ b/packages/stocked/test/hooks/useStockValue.test.tsx @@ -0,0 +1,82 @@ +import React, { PropsWithChildren } from 'react'; +import { act, renderHook, waitFor } from '@testing-library/react'; +import { createPxth, Pxth } from 'pxth'; +import { beforeEach, describe, expect, it } from 'vitest'; + +import { Stock, StockContext, useStock, useStockValue } from '../../src'; + +const initialValues = { + hello: 'test', + parent: { + child: 'value', + }, + array: [ + 1, + { + value: 'second', + }, + ], +}; + +let stock: Stock; + +const wrapper = ({ children }: PropsWithChildren) => ( + }>{children} +); + +const renderUseStockValue = (path: Pxth, useContext = true) => + renderHook(({ path }: { path: Pxth }) => useStockValue(path, useContext ? undefined : stock), { + wrapper: useContext ? wrapper : undefined, + initialProps: { + path, + }, + }); + +beforeEach(() => { + const { result } = renderHook(() => useStock({ initialValues }), { wrapper }); + stock = result.current; +}); + +describe('Testing "useStockValue" with context stock', () => { + it('Should return new value after update', async () => { + const { result } = renderUseStockValue(createPxth(['hello'])); + + expect(result.current).toBe(initialValues.hello); + + const newValue = 'newValue'; + + act(() => { + stock.setValue(createPxth(['hello']), newValue); + }); + + await waitFor(() => expect(result.current).toBe(newValue)); + }); + + // TODO decide on the behavior when path changes + it.skip('should return new value when path changes', async () => { + const initialPath = createPxth(['hello']); + const otherPath = createPxth(['parent', 'child']); + + const { result, rerender } = renderUseStockValue(initialPath); + + rerender({ path: otherPath }); + + expect(result.current).toBe('value'); + }); +}); + +describe('Testing "useStockValue" with provided stock', () => { + it('Should return new value after update', async () => { + const { result } = renderUseStockValue(createPxth(['hello']), false); + + expect(result.current).toBe(initialValues.hello); + + const newValue = 'newValue'; + + act(() => { + stock.setValue(createPxth(['hello']), newValue); + }); + + await waitFor(() => expect(result.current).toBe(newValue)); + }); +}); diff --git a/packages/stocked/test/typings/MappingProxy.test.ts b/packages/stocked/test/typings/MappingProxy.test.ts new file mode 100644 index 00000000..7aad25e0 --- /dev/null +++ b/packages/stocked/test/typings/MappingProxy.test.ts @@ -0,0 +1,651 @@ +import { SetStateAction } from 'react'; +import isFunction from 'lodash/isFunction'; +import { createPxth, deepGet, deepSet, getPxthSegments, Pxth, samePxth } from 'pxth'; +import { describe, expect, it, Mock, vi } from 'vitest'; + +import { MappingProxy, Observer, ProxyMapSource } from '../../src/typings'; + +type RegisteredUser = { + registrationDate: Date; + personalData: { + name: { + firstName: string; + lastName: string; + }; + birthday: Date; + }; +}; + +const getUserMapSource = (): ProxyMapSource => { + return { + registrationDate: createPxth(['registeredUser', 'dates', 'registration']), + personalData: { + name: { + firstName: createPxth(['registeredUser', 'name']), + lastName: createPxth(['registeredUser', 'surname']), + }, + birthday: createPxth(['dateOfBirth']), + }, + }; +}; + +describe('Mapping proxy', () => { + it('should instantiate', () => { + expect(() => new MappingProxy({}, createPxth(['']))).not.toThrowError(); + }); + + it('observe/stopObserving value', () => { + const proxy = new MappingProxy( + { hello: createPxth(['a', 'b', 'c']), bye: createPxth(['a', 'b', 'd']) }, + createPxth(['asdf']), + ); + + const defaultObserve = vi.fn(); + const observer = vi.fn(); + + defaultObserve.mockReturnValue(0); + + proxy.watch(createPxth(['asdf', 'hello']), observer, defaultObserve); + + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['a', 'b', 'c']); + + defaultObserve.mockClear(); + + proxy.watch(createPxth(['asdf', 'bye']), observer, defaultObserve); + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['a', 'b', 'd']); + }); + + it('observe/stopObserving value - with "watchEffect"', () => { + const proxy = new MappingProxy( + { hello: createPxth(['a', 'b', 'c']), bye: createPxth(['a', 'b', 'd']) }, + createPxth(['asdf']), + ); + + const defaultObserve = vi.fn(); + const observer = vi.fn(); + + defaultObserve.mockReturnValue(0); + + proxy.watchEffect(createPxth(['asdf', 'hello']), observer, defaultObserve); + + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['a', 'b', 'c']); + + defaultObserve.mockClear(); + + proxy.watchEffect(createPxth(['asdf', 'bye']), observer, defaultObserve); + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['a', 'b', 'd']); + }); + + it('observe/stopObserving (empty mapping path)', () => { + const proxy = new MappingProxy(createPxth(['a', 'd', 'c']), createPxth(['asdf'])); + + const defaultObserve = vi.fn(); + const observer = vi.fn(); + + defaultObserve.mockReturnValue(0); + + proxy.watch(createPxth(['asdf']), observer, defaultObserve); + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['a', 'd', 'c']); + + defaultObserve.mockClear(); + }); + + it('observe/stopObserving value (empty parent path)', () => { + const proxy = new MappingProxy( + { hello: createPxth(['a', 'd', 'c']), bye: createPxth(['b', 'b', 'd']) }, + createPxth([]), + ); + + const defaultObserve = vi.fn(); + const observer = vi.fn(); + + defaultObserve.mockReturnValue(0); + + proxy.watch(createPxth(['hello']), observer, defaultObserve); + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['a', 'd', 'c']); + + defaultObserve.mockClear(); + + proxy.watch(createPxth(['bye']), observer, defaultObserve); + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['b', 'b', 'd']); + }); + + it('calling observer fns', () => { + const fullUser = { + personalData: { + name: { + firstName: 'Hello', + lastName: 'World', + }, + birthday: new Date('2020.12.26'), + }, + registrationDate: new Date('2020.12.31'), + notify: true, + }; + const rawData = { + registeredUser: { + name: fullUser.personalData.name.firstName, + surname: fullUser.personalData.name.lastName, + dates: { + registration: fullUser.registrationDate, + }, + }, + dateOfBirth: fullUser.personalData.birthday, + }; + + const proxy = new MappingProxy(getUserMapSource(), createPxth(['registeredUser'])); + + const observers: Observer[] = []; + + const defaultObserve = vi.fn((_, observer) => { + observers.push(observer); + return () => observers.splice(observers.indexOf(observer), 1); + }); + const observer = vi.fn(); + + proxy.watch(createPxth(['registeredUser', 'personalData', 'name', 'firstName']), observer, defaultObserve); + + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['registeredUser', 'name']); + + defaultObserve.mockClear(); + + proxy.watch(createPxth(['registeredUser', 'personalData', 'name']), observer, defaultObserve); + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['registeredUser']); + + defaultObserve.mockClear(); + + proxy.watch(createPxth(['registeredUser', 'personalData']), observer, defaultObserve); + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual([]); + + observers[0](rawData.registeredUser.name); + + expect(observer).toBeCalledWith(fullUser.personalData.name.firstName); + + observer.mockClear(); + + observers[1](rawData.registeredUser); + expect(observer).toBeCalledWith(fullUser.personalData.name); + + observer.mockClear(); + + observers[2](rawData); + expect(observer).toBeCalledWith(fullUser.personalData); + }); + + it('calling observer fns - with watchEffect', () => { + const fullUser = { + personalData: { + name: { + firstName: 'Hello', + lastName: 'World', + }, + birthday: new Date('2020.12.26'), + }, + registrationDate: new Date('2020.12.31'), + notify: true, + }; + const rawData = { + registeredUser: { + name: fullUser.personalData.name.firstName, + surname: fullUser.personalData.name.lastName, + dates: { + registration: fullUser.registrationDate, + }, + }, + dateOfBirth: fullUser.personalData.birthday, + }; + + const proxy = new MappingProxy(getUserMapSource(), createPxth(['registeredUser'])); + + const observers: Observer[] = []; + + const defaultObserve = vi.fn((path, observer) => { + observer(deepGet(rawData, path)); + observers.push(observer); + return () => observers.splice(observers.indexOf(observer), 1); + }); + const observer = vi.fn(); + + proxy.watchEffect( + createPxth(['registeredUser', 'personalData', 'name', 'firstName']), + observer, + defaultObserve, + ); + + expect(observer).toBeCalledWith(fullUser.personalData.name.firstName); + observer.mockClear(); + + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['registeredUser', 'name']); + + defaultObserve.mockClear(); + + proxy.watchEffect(createPxth(['registeredUser', 'personalData', 'name']), observer, defaultObserve); + + expect(observer).toBeCalledWith(fullUser.personalData.name); + observer.mockClear(); + + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual(['registeredUser']); + + defaultObserve.mockClear(); + + proxy.watchEffect(createPxth(['registeredUser', 'personalData']), observer, defaultObserve); + + expect(observer).toBeCalledWith(fullUser.personalData); + observer.mockClear(); + + expect(getPxthSegments(defaultObserve.mock.calls[0][0])).toStrictEqual([]); + }); + + it('calling observer fns (complex cases)', () => { + const fullData = { + truck: { + driver: { + name: 'Hello', + surname: 'Bye', + phone: '+333533333', + }, + info: { + trailerNo: 'AAA111', + truckNo: 'AAA222', + }, + owner: { + companyId: 0, + companyName: 'Hello World', + contacts: [ + { + contactId: 0, + name: 'Bill Bill', + contactInfo: { + email: 'bill.bill@mail.loc', + phone: '+333 333 333', + }, + }, + ], + }, + }, + }; + const rawData = { + truck: { + plate_no: fullData.truck.info.truckNo, + }, + trailer: { + plate_no: fullData.truck.info.trailerNo, + }, + company: fullData.truck.owner.companyName, + contact_name: fullData.truck.owner.contacts[0].name, + contact_id: fullData.truck.owner.contacts[0].contactId, + contact_email: fullData.truck.owner.contacts[0].contactInfo.email, + contact_phone: fullData.truck.owner.contacts[0].contactInfo.phone, + }; + + const proxy = new MappingProxy<{ + info: { + truckNo: string; + trailerNo: string; + }; + owner: { + name: string; + contactId: number; + contactInfo: { + email: string; + phone: string; + }; + }; + }>( + { + info: { + truckNo: createPxth(['truck', 'plate_no']), + trailerNo: createPxth(['trailer', 'plate_no']), + }, + owner: { + name: createPxth(['contact_name']), + contactId: createPxth(['contact_id']), + contactInfo: { + email: createPxth(['contact_email']), + phone: createPxth(['contact_phone']), + }, + }, + }, + createPxth(['truck']), + ); + + const observers: Observer[] = []; + + const defaultWatch = vi.fn((_, observer) => { + observers.push(observer); + return () => observers.splice(observers.indexOf(observer), 1); + }); + const observer = vi.fn(); + + proxy.watch(createPxth(['truck', 'owner']), observer, defaultWatch); + expect(getPxthSegments(defaultWatch.mock.calls[0][0])).toStrictEqual([]); + + defaultWatch.mockClear(); + + proxy.watch(createPxth(['truck', 'info']), observer, defaultWatch); + expect(getPxthSegments(defaultWatch.mock.calls[0][0])).toStrictEqual([]); + + observers[0](rawData); + expect(observer).toBeCalledWith(fullData.truck.owner.contacts[0]); + + observer.mockClear(); + + observers[1](rawData); + expect(observer).toBeCalledWith(fullData.truck.info); + }); + + it('should set proxied value', () => { + const proxy = new MappingProxy(getUserMapSource(), createPxth(['registeredUser'])); + + const defaultSetValue = vi.fn(); + const defaultGetValue = vi.fn(); + + proxy.setValue( + createPxth(['registeredUser', 'personalData', 'name', 'firstName']), + 'Hello', + defaultSetValue, + defaultGetValue, + ); + + expect(getPxthSegments(defaultSetValue.mock.calls[0][0])).toStrictEqual(['registeredUser', 'name']); + expect(defaultSetValue).toBeCalledWith(expect.anything(), 'Hello'); + + defaultSetValue.mockClear(); + + proxy.setValue( + createPxth(['registeredUser', 'personalData', 'name']), + { firstName: 'As', lastName: 'Df' }, + defaultSetValue, + defaultGetValue, + ); + + expect( + defaultSetValue.mock.calls.findIndex( + ([path, value]) => samePxth(path, createPxth(['registeredUser', 'name'])) && value === 'As', + ) !== -1, + ).toBeTruthy(); + + expect( + defaultSetValue.mock.calls.findIndex( + ([path, value]) => samePxth(path, createPxth(['registeredUser', 'surname'])) && value === 'Df', + ) !== -1, + ).toBeTruthy(); + }); + + it('should set proxied value based on the old value', () => { + const proxy = new MappingProxy(getUserMapSource(), createPxth(['registeredUser'])); + + const defaultSetValue = vi.fn(); + const getStringValue = vi.fn(() => 'old value'); + + proxy.setValue( + createPxth(['registeredUser', 'personalData', 'name', 'firstName']), + (old) => old + ' updated', + defaultSetValue, + getStringValue as (path: Pxth) => U, + ); + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + expect(getPxthSegments((getStringValue as Mock<(...args: any[]) => any>).mock.calls[0][0])).toStrictEqual([ + 'registeredUser', + 'name', + ]); + expect(getPxthSegments(defaultSetValue.mock.calls[0][0])).toStrictEqual(['registeredUser', 'name']); + expect(defaultSetValue).toBeCalledWith(expect.anything(), 'old value updated'); + + defaultSetValue.mockClear(); + const getObjectValue = vi.fn(() => ({ firstName: 'As', lastName: 'Df' })) as (path: Pxth) => U; + + proxy.setValue( + createPxth(['registeredUser', 'personalData', 'name']), + (old: object) => ({ ...old, lastName: 'updated' }), + defaultSetValue, + getObjectValue, + ); + + expect( + defaultSetValue.mock.calls.findIndex( + ([path, value]) => samePxth(path, createPxth(['registeredUser', 'name'])) && value === 'As', + ) !== -1, + ).toBeTruthy(); + + expect( + defaultSetValue.mock.calls.findIndex( + ([path, value]) => samePxth(path, createPxth(['registeredUser', 'surname'])) && value === 'updated', + ) !== -1, + ).toBeTruthy(); + }); + + it('should get proxied value', () => { + const fullUser = { + personalData: { + name: { + firstName: 'Hello', + lastName: 'World', + }, + birthday: new Date('2020.12.26'), + }, + registrationDate: new Date('2020.12.31'), + notify: true, + }; + const rawData = { + registeredUser: { + name: fullUser.personalData.name.firstName, + surname: fullUser.personalData.name.lastName, + dates: { + registration: fullUser.registrationDate, + }, + }, + dateOfBirth: fullUser.personalData.birthday, + }; + + const proxy = new MappingProxy(getUserMapSource(), createPxth(['registeredUser'])); + + const defaultGet = (path: Pxth) => deepGet(rawData, path); + + expect(proxy.getValue(createPxth(['registeredUser', 'personalData', 'name', 'firstName']), defaultGet)).toBe( + fullUser.personalData.name.firstName, + ); + expect(proxy.getValue(createPxth(['registeredUser', 'personalData', 'name']), defaultGet)).toStrictEqual( + fullUser.personalData.name, + ); + expect(proxy.getValue(createPxth(['registeredUser', 'personalData', 'birthday']), defaultGet)).toStrictEqual( + fullUser.personalData.birthday, + ); + }); + + it('should return normal path from proxied path', () => { + const proxy = new MappingProxy( + { + ...getUserMapSource(), + location: createPxth<{ city: string }>(['registeredUser', 'personalData', 'home_location']), + }, + createPxth(['registeredUser']), + ); + + expect(getPxthSegments(proxy.getNormalPath(createPxth(['registeredUser', 'personalData'])))).toStrictEqual([]); + expect(getPxthSegments(proxy.getNormalPath(createPxth(['registeredUser', 'registrationDate'])))).toStrictEqual([ + 'registeredUser', + 'dates', + 'registration', + ]); + expect( + getPxthSegments(proxy.getNormalPath(createPxth(['registeredUser', 'personalData', 'name']))), + ).toStrictEqual(['registeredUser']); + expect(getPxthSegments(proxy.getNormalPath(createPxth(['registeredUser', 'location', 'city'])))).toStrictEqual([ + 'registeredUser', + 'personalData', + 'home_location', + 'city', + ]); + }); + + it('should return proxied path from normal path', () => { + const proxy = new MappingProxy( + { + registrationDate: createPxth(['registeredUser', 'dates', 'registration']), + personalData: { + name: { + firstName: createPxth(['registeredUser', 'name']), + lastName: createPxth(['registeredUser', 'surname']), + }, + birthday: createPxth(['dateOfBirth']), + }, + }, + createPxth(['registeredUser']), + ); + + expect( + getPxthSegments(proxy.getProxiedPath(createPxth(['registeredUser', 'dates', 'registration']))), + ).toStrictEqual(['registeredUser', 'registrationDate']); + expect(getPxthSegments(proxy.getProxiedPath(createPxth(['registeredUser', 'name'])))).toStrictEqual([ + 'registeredUser', + 'personalData', + 'name', + 'firstName', + ]); + expect(() => proxy.getProxiedPath(createPxth(['registeredUser', 'personalData']))).toThrow(); + }); + + it('should getValue from nested path', () => { + const proxy = new MappingProxy( + { + location: createPxth(['core', 'values', 'location_from']), + cmpId: createPxth(['core', 'cmp_id_from']), + }, + createPxth(['compound']), + ); + + const values = { + core: { + cmp_id_from: 5, + values: { + location_from: { + id: 24, + }, + }, + }, + }; + + const fn = vi.fn((path) => { + return deepGet(values, path); + }); + const value = proxy.getValue(createPxth(['compound', 'location', 'id']), fn as (path: Pxth) => U); + expect(value).toBe(24); + }); + + it('should setValue to nested path', () => { + const proxy = new MappingProxy( + { + location: createPxth(['core', 'values', 'location_from']), + cmpId: createPxth(['core', 'cmp_id_from']), + }, + createPxth(['compound']), + ); + + const values = { + core: { + cmp_id_from: 5, + values: { + location_from: { + id: 24, + info: { + street: 'Gedimino g.', + city: 'Vilnius', + }, + }, + }, + }, + }; + + const defaultSetValue: (path: Pxth, value: SetStateAction) => void = vi.fn( + (path: Pxth, value: SetStateAction) => { + deepSet(values, path, isFunction(value) ? deepGet(values, path) : value); + }, + ); + const defaultGetValue = vi.fn(); + + proxy.setValue(createPxth(['compound', 'location', 'id']), 42, defaultSetValue, defaultGetValue); + expect(values).toStrictEqual({ + core: { + cmp_id_from: 5, + values: { + location_from: { + id: 42, + info: { + street: 'Gedimino g.', + city: 'Vilnius', + }, + }, + }, + }, + }); + + proxy.setValue( + createPxth(['compound', 'location', 'info']), + { + city: 'Kaunas', + street: 'Teodoro', + }, + defaultSetValue, + defaultGetValue, + ); + expect(values).toStrictEqual({ + core: { + cmp_id_from: 5, + values: { + location_from: { + id: 42, + info: { + city: 'Kaunas', + street: 'Teodoro', + }, + }, + }, + }, + }); + }); + + it('should watch value from nested path', () => { + const proxy = new MappingProxy( + { + location: createPxth(['core', 'values', 'location_from']), + cmpId: createPxth(['core', 'cmp_id_from']), + }, + createPxth(['compound']), + ); + + const observer = vi.fn(); + const defaultWatch = vi.fn((_path, proxiedObserver: (value: unknown) => void) => { + proxiedObserver(42); + return vi.fn(); + }); + + proxy.watch( + createPxth(['compound', 'location', 'id']), + observer, + defaultWatch as (path: Pxth, observer: Observer) => () => void, + ); + + expect(getPxthSegments(defaultWatch.mock.calls[0][0])).toStrictEqual(['core', 'values', 'location_from', 'id']); + expect(defaultWatch.mock.calls[0][1]).toBeDefined(); + expect(observer).toBeCalledWith(42); + }); + + it('should handle arrays', () => { + const proxy = new MappingProxy( + { + values: [ + { + hello: createPxth(['real', 'path']), + }, + ], + }, + createPxth(['proxied_path']), + ); + + expect( + getPxthSegments(proxy.getNormalPath(createPxth(['proxied_path', 'values', '0', 'hello']))), + ).toStrictEqual(['real', 'path']); + }); +}); diff --git a/packages/stocked/test/typings/StockProxy.test.ts b/packages/stocked/test/typings/StockProxy.test.ts new file mode 100644 index 00000000..dbc85743 --- /dev/null +++ b/packages/stocked/test/typings/StockProxy.test.ts @@ -0,0 +1,19 @@ +import { createPxth } from 'pxth'; +import { describe, expect, it } from 'vitest'; + +import { DummyProxy } from '../DummyProxy'; + +describe('Proxy activation', () => { + it('should activate proxy', () => { + const proxy = new DummyProxy(createPxth(['asdf'])); + proxy.activate(); + expect(Object.isFrozen(proxy)).toBeTruthy(); + expect(proxy.isActive()).toBeTruthy(); + }); + it('should not let to edit active proxy', () => { + const proxy = new DummyProxy(createPxth(['asdf'])); + proxy.activate(); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + expect(() => ((proxy as any).path = 'asdfsdf')).toThrow(); + }); +}); diff --git a/packages/stocked/test/utils/ObserverArray.test.ts b/packages/stocked/test/utils/ObserverArray.test.ts new file mode 100644 index 00000000..1d6ca665 --- /dev/null +++ b/packages/stocked/test/utils/ObserverArray.test.ts @@ -0,0 +1,73 @@ +import { describe, expect, it, vi } from 'vitest'; + +import { ObserverArray } from '../../src/utils/ObserverArray'; + +describe('ObserverArray "call" function', () => { + it('should call all functions', () => { + const observer1 = vi.fn(); + + const arr = new ObserverArray(); + arr.add(observer1); + arr.add(observer1); + arr.add(observer1); + + arr.call(null); + + expect(observer1).toBeCalledTimes(3); + }); + + it('should receive message', () => { + const observer1 = vi.fn(); + const observer2 = vi.fn(); + const observer3 = vi.fn(); + + const message = 'sample message'; + + const arr = new ObserverArray(); + + arr.add(observer1); + arr.add(observer2); + arr.add(observer3); + + arr.call(message); + + expect(observer1).toBeCalledWith(message); + expect(observer2).toBeCalledWith(message); + expect(observer3).toBeCalledWith(message); + }); +}); + +describe('ObserverArray "remove" function', () => { + it('should remove observer', () => { + const observer = vi.fn(); + const removedObserver = vi.fn(); + + const arr = new ObserverArray(); + + arr.add(observer); + const key = arr.add(removedObserver); + + arr.remove(key); + + arr.call(null); + + expect(removedObserver).not.toBeCalled(); + expect(observer).toBeCalled(); + }); +}); + +describe('ObserverArray "isEmpty" function', () => { + it('should return true/false, depending on array size', () => { + const observer = vi.fn(); + + const arr = new ObserverArray(); + + const key = arr.add(observer); + + expect(arr.isEmpty()).toBeFalsy(); + + arr.remove(key); + + expect(arr.isEmpty()).toBeTruthy(); + }); +}); diff --git a/packages/stocked/test/utils/areProxyMapsEqual.test.ts b/packages/stocked/test/utils/areProxyMapsEqual.test.ts new file mode 100644 index 00000000..fa17ab76 --- /dev/null +++ b/packages/stocked/test/utils/areProxyMapsEqual.test.ts @@ -0,0 +1,130 @@ +import { createPxth } from 'pxth'; +import { describe, expect, it } from 'vitest'; + +import { areProxyMapsEqual } from '../../src/utils/areProxyMapsEqual'; + +describe('areProxyMapsEqual', () => { + it('should return false if objects have different amount of entries', () => { + expect(areProxyMapsEqual({}, { a: createPxth([]) })).toBeFalsy(); + expect(areProxyMapsEqual({ a: createPxth([]) }, {})).toBeFalsy(); + expect(areProxyMapsEqual({ a: createPxth([]) }, { a: createPxth([]), b: createPxth([]) })).toBeFalsy(); + }); + + it('should return false when objects differ', () => { + expect(areProxyMapsEqual({ a: createPxth(['hello1']) }, { a: createPxth(['hello']) })).toBeFalsy(); + expect(areProxyMapsEqual({ a: createPxth(['bye']) }, { b: createPxth(['bye']) })).toBeFalsy(); + }); + + it('should return true if objects are same', () => { + expect(areProxyMapsEqual({ a: createPxth([]) }, { a: createPxth([]) })).toBeTruthy(); + expect(areProxyMapsEqual({ a: createPxth(['bye']) }, { a: createPxth(['bye']) })).toBeTruthy(); + }); + + it('should compare 2 nested objects', () => { + expect( + areProxyMapsEqual( + { + registrationDate: createPxth(['registeredUser', 'dates', 'registration']), + personalData: { + name: { + firstName: createPxth(['registeredUser', 'name']), + lastName: createPxth(['registeredUser', 'surname']), + }, + birthday: createPxth(['dateOfBirth']), + }, + }, + { + registrationDate: createPxth(['registeredUser', 'dates', 'registration']), + personalData: { + name: { + firstName: createPxth(['registeredUser', 'name']), + lastName: createPxth(['registeredUser', 'surname']), + }, + birthday: createPxth(['dateOfBirth']), + }, + }, + ), + ).toBeTruthy(); + + expect( + areProxyMapsEqual( + { + registrationDate: createPxth(['registeredUser', 'dates', 'registration']), + personalData: { + name: { + firstName: createPxth(['registeredUser', 'name']), + lastName: createPxth(['registeredUser', 'surname']), + }, + birthday: createPxth(['dateOfBirth']), + }, + }, + { + registrationDate: createPxth(['registeredUser', 'dates', 'registration']), + personalData: { + name: { + firstName: createPxth(['registeredUser', 'name']), + lastName: createPxth(['registeredUser', 'surname']), + // Added additional property + additionalData: createPxth(['hello', 'world']), + }, + birthday: createPxth(['dateOfBirth']), + }, + }, + ), + ).toBeFalsy(); + + expect( + areProxyMapsEqual( + { + registrationDate: createPxth(['registeredUser', 'dates', 'registration']), + personalData: { + name: { + // Changed path + firstName: createPxth(['name', 'registeredUser']), + lastName: createPxth(['registeredUser', 'surname']), + }, + birthday: createPxth(['dateOfBirth']), + }, + }, + { + registrationDate: createPxth(['registeredUser', 'dates', 'registration']), + personalData: { + name: { + firstName: createPxth(['registeredUser', 'name']), + lastName: createPxth(['registeredUser', 'surname']), + additionalData: createPxth(['hello', 'world']), + }, + birthday: createPxth(['dateOfBirth']), + }, + }, + ), + ).toBeFalsy(); + + expect( + areProxyMapsEqual( + { + registrationDate: createPxth(['registeredUser', 'dates', 'registration']), + // Changed name + personalDataMODIFIED: { + name: { + firstName: createPxth(['name', 'registeredUser']), + lastName: createPxth(['registeredUser', 'surname']), + }, + birthday: createPxth(['dateOfBirth']), + }, + }, + { + registrationDate: createPxth(['registeredUser', 'dates', 'registration']), + personalData: { + name: { + firstName: createPxth(['registeredUser', 'name']), + lastName: createPxth(['registeredUser', 'surname']), + additionalData: createPxth(['hello', 'world']), + }, + birthday: createPxth(['dateOfBirth']), + }, + }, + ), + ).toBeFalsy(); + }); +}); diff --git a/packages/stocked/test/utils/useInterceptors.test.ts b/packages/stocked/test/utils/useInterceptors.test.ts new file mode 100644 index 00000000..15dab76d --- /dev/null +++ b/packages/stocked/test/utils/useInterceptors.test.ts @@ -0,0 +1,271 @@ +import { act, renderHook, waitFor } from '@testing-library/react'; +import { createPxth, getPxthSegments, Pxth } from 'pxth'; +import { describe, expect, it, Mock, vi } from 'vitest'; + +import { MappingProxy, StockProxy, useStock } from '../../src'; +import { intercept, useInterceptors } from '../../src/utils/useInterceptors'; +import { DummyProxy } from '../DummyProxy'; + +const defaultInitialValues = { + hello: '', + dest: { + bye: 'asdf', + l: 0, + }, +}; + +const renderUseInterceptorsHook = (initialValues: T, proxy?: StockProxy) => { + const { result } = renderHook(() => useStock({ initialValues })); + + const stock = result.current; + return [renderHook(() => useInterceptors(stock, proxy)), stock] as const; +}; + +describe('hit cases', () => { + it('no proxy', () => { + const [{ result }] = renderUseInterceptorsHook(defaultInitialValues); + + const observer = vi.fn(); + act(() => { + const cleanup = result.current.watch(createPxth(['hello']), observer); + result.current.setValue(createPxth(['hello']), 'asdf'); + cleanup(); + result.current.setValue(createPxth(['hello']), 'ba'); + }); + + expect(observer).toBeCalledTimes(1); + expect(observer).toBeCalledWith('asdf'); + }); + it('no proxy - with "watchEffect"', () => { + const [{ result }] = renderUseInterceptorsHook(defaultInitialValues); + + const observer = vi.fn(); + act(() => { + const cleanup = result.current.watchEffect(createPxth(['dest', 'bye']), observer); + cleanup(); + }); + + expect(observer).toBeCalledTimes(1); + expect(observer).toBeCalledWith('asdf'); + }); + it('non activated proxy', () => { + expect(() => renderUseInterceptorsHook(defaultInitialValues, new DummyProxy(createPxth(['asdf'])))).toThrow(); + }); +}); + +describe('intercept', () => { + it('no proxy', () => { + const standard = vi.fn(); + const custom = vi.fn(); + intercept(undefined, createPxth([]), standard, custom, []); + expect(standard).toBeCalled(); + expect(custom).not.toBeCalled(); + }); + it('proxy', () => { + const proxy = new DummyProxy(createPxth(['asdf'])); + const standard = vi.fn(); + const custom = vi.fn(); + intercept(proxy, createPxth(['asdf']), standard, custom, []); + expect(standard).not.toBeCalled(); + expect(custom).toBeCalled(); + }); + it('proxy (nested interception)', () => { + const proxy = new DummyProxy(createPxth(['asdf'])); + const standard = vi.fn(); + const custom = vi.fn(); + intercept(proxy, createPxth(['asdf', 'hello', 'b']), standard, custom, []); + expect(standard).not.toBeCalled(); + expect(custom).toBeCalled(); + }); + it('ignoring proxy', () => { + const proxy = new DummyProxy(createPxth(['asdf'])); + const standard = vi.fn(); + const custom = vi.fn(); + intercept(proxy, createPxth(['basdf.hello.wy']), standard, custom, []); + expect(standard).toBeCalled(); + expect(custom).not.toBeCalled(); + }); +}); + +describe('proxy', () => { + it('should call proxy functions', () => { + const proxy = new DummyProxy(createPxth(['dest'])); + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const watch: Mock<(...args: any[]) => () => void> = vi.fn(() => () => {}); + const setValue = vi.fn(); + const getValue = vi.fn(); + + proxy.watch = watch; + proxy.setValue = setValue; + proxy.getValue = getValue; + proxy.activate(); + const [{ result }] = renderUseInterceptorsHook(defaultInitialValues, proxy); + + const observer = vi.fn(); + + act(() => { + const cleanup = result.current.watch(createPxth(['dest']), observer); + const cleanup2 = result.current.watch(createPxth(['asdf']), observer); + result.current.setValue(createPxth(['dest']), 'asdf'); + result.current.setValue(createPxth(['asdf']), 'asdf'); + cleanup(); + result.current.getValue(createPxth(['dest'])); + result.current.getValue(createPxth(['asdf'])); + cleanup2(); + }); + + expect(getPxthSegments(watch.mock.calls[0][0])).toStrictEqual(['dest']); + expect(watch).toBeCalledWith(expect.anything(), observer, expect.any(Function)); + expect(watch).toBeCalledTimes(1); + expect(getPxthSegments(setValue.mock.calls[0][0])).toStrictEqual(['dest']); + expect(setValue).toBeCalledWith(expect.anything(), 'asdf', expect.any(Function), expect.any(Function)); + expect(setValue).toBeCalledTimes(1); + expect(getPxthSegments(getValue.mock.calls[0][0])).toStrictEqual(['dest']); + expect(getValue).toBeCalledTimes(1); + }); + + it('should call proxy functions - with "watchEffect"', () => { + const proxy = new DummyProxy(createPxth(['dest'])); + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const watchEffect: Mock<(...args: any[]) => () => void> = vi.fn(() => () => {}); + + proxy.watchEffect = watchEffect; + proxy.activate(); + const [{ result }] = renderUseInterceptorsHook(defaultInitialValues, proxy); + + const observer = vi.fn(); + + act(() => { + const cleanup = result.current.watchEffect(createPxth(['dest']), observer); + const cleanup2 = result.current.watchEffect(createPxth(['asdf']), observer); + cleanup(); + cleanup2(); + }); + + expect(getPxthSegments(watchEffect.mock.calls[0][0])).toStrictEqual(['dest']); + expect(watchEffect).toBeCalledWith(expect.anything(), observer, expect.any(Function)); + expect(watchEffect).toBeCalledTimes(1); + expect(observer).toBeCalled(); + }); + + it('should handle setValues / getValues properly', async () => { + const proxy = new DummyProxy(createPxth(['dest'])); + + const watch = vi.fn(() => () => {}); + const setValue = vi.fn(); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const getValue = vi.fn((_path: Pxth) => 'Test get value'); + + proxy.watch = watch; + proxy.setValue = setValue; + proxy.getValue = getValue as (path: Pxth, defaultGetValue: (path: Pxth) => U) => V; + proxy.activate(); + const [{ result }] = renderUseInterceptorsHook(defaultInitialValues, proxy); + + result.current.setValues({ + hello: 'asdf', + dest: { + bye: '', + l: 15, + }, + }); + + await waitFor(() => + expect(result.current.getValues()).toStrictEqual({ + hello: 'asdf', + dest: 'Test get value', + }), + ); + + expect(getPxthSegments(setValue.mock.calls[0][0])).toStrictEqual(['dest']); + expect(setValue).toBeCalledTimes(1); + + expect(getPxthSegments(getValue.mock.calls[0][0])).toStrictEqual(['dest']); + expect(getValue).toBeCalledTimes(1); + }); + + it('should set entire values object', async () => { + const initialValues = { + userName: 'Harry', + userSurname: 'Potter', + }; + + const proxy = new MappingProxy( + { + driver: { + name: createPxth(['userName']), + surname: createPxth(['userSurname']), + }, + }, + createPxth<{ driver: { name: string; surname: string } }>(['proxy']), + ); + + proxy.activate(); + + const [{ result }, realStock] = renderUseInterceptorsHook(initialValues, proxy); + + const proxiedStock = result.current; + + proxiedStock.setValues({ + proxy: { + driver: { + name: 'John', + surname: 'Weasley', + }, + }, + userName: 'THIS SHOULD BE OVERRIDED', + userSurname: 'THIS SHOULD BE OVERRIDED', + } as typeof initialValues); + + await waitFor(() => { + expect(proxiedStock.getValues()).toStrictEqual({ + proxy: { + driver: { + name: 'John', + surname: 'Weasley', + }, + }, + userName: 'John', + userSurname: 'Weasley', + }); + + expect(realStock.getValues()).toStrictEqual({ + userName: 'John', + userSurname: 'Weasley', + }); + }); + }); + + it('should be able to pass an update callback to construct new state', async () => { + const initialValues = { + userName: 'Harry', + userSurname: 'Potter', + }; + + const proxy = new MappingProxy( + { + driver: { + name: createPxth(['userName']), + surname: createPxth(['userSurname']), + }, + }, + createPxth<{ driver: { name: string; surname: string } }>(['proxy']), + ); + + proxy.activate(); + + const [{ result }, realStock] = renderUseInterceptorsHook(initialValues, proxy); + + const proxiedStock = result.current; + + const valuePath = createPxth(['proxy', 'driver', 'name']); + proxiedStock.setValue(valuePath, (old) => old + ' updated'); + + await waitFor(() => { + expect(proxiedStock.getValue(valuePath)).toBe('Harry updated'); + expect(realStock.getValue(createPxth(['userName']))).toBe('Harry updated'); + }); + }); +}); diff --git a/packages/stocked/test/utils/useLazyRef.test.ts b/packages/stocked/test/utils/useLazyRef.test.ts new file mode 100644 index 00000000..633e81db --- /dev/null +++ b/packages/stocked/test/utils/useLazyRef.test.ts @@ -0,0 +1,31 @@ +import { renderHook } from '@testing-library/react'; +import { describe, expect, it, vi } from 'vitest'; + +import { useLazyRef } from '../../src/utils/useLazyRef'; + +describe('Lazy initializing test', () => { + it('should initialize once', () => { + const initializer = vi.fn(); + + initializer.mockReturnValue(1); + + const { rerender } = renderHook(() => useLazyRef(initializer)); + + rerender(); + rerender(); + rerender(); + rerender(); + + expect(initializer).toBeCalledTimes(1); + }); + + it('should return initialized value', () => { + const initializer = vi.fn(); + + initializer.mockReturnValue(1); + + const { result } = renderHook(() => useLazyRef(initializer)); + + expect(result.current.current).toBe(1); + }); +}); diff --git a/packages/stocked/tsconfig.json b/packages/stocked/tsconfig.json new file mode 100644 index 00000000..c869b7f5 --- /dev/null +++ b/packages/stocked/tsconfig.json @@ -0,0 +1,36 @@ +{ + // see https://www.typescriptlang.org/tsconfig to better understand tsconfigs + "include": ["src", "types"], + "compilerOptions": { + "module": "esnext", + "lib": ["dom", "esnext"], + "importHelpers": true, + // output .d.ts declaration files for consumers + "declaration": true, + // output .js.map sourcemap files for consumers + "sourceMap": true, + // match output dir to input dir. e.g. dist/index instead of dist/src/index + "rootDir": ".", + // stricter type-checking for stronger correctness. Recommended by TS + "strict": true, + // linter checks for common issues + "noImplicitReturns": true, + "noFallthroughCasesInSwitch": true, + // noUnused* overlap with @typescript-eslint/no-unused-vars, can disable if duplicative + "noUnusedLocals": true, + "noUnusedParameters": true, + // use Node's module resolution algorithm, instead of the legacy TS one + "moduleResolution": "node", + // transpile JSX to React.createElement + "jsx": "react", + // interop between ESM and CJS modules. Recommended by TS + "esModuleInterop": true, + // significant perf increase by skipping checking .d.ts files, particularly those in node_modules. Recommended by TS + "skipLibCheck": true, + // error out if import and file system have a casing mismatch. Recommended by TS + "forceConsistentCasingInFileNames": true, + // `tsdx build` ignores this option, but it is commonly used when type-checking separately with `tsc` + "noEmit": true, + "resolveJsonModule": true + } +} diff --git a/packages/stocked/vitest.config.ts b/packages/stocked/vitest.config.ts new file mode 100644 index 00000000..ad9b0155 --- /dev/null +++ b/packages/stocked/vitest.config.ts @@ -0,0 +1,7 @@ +import { defineConfig } from 'vitest/config'; + +export default defineConfig({ + test: { + environment: 'jsdom', + }, +}); diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 72c77593..aca7c6bb 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -61,11 +61,11 @@ importers: version: 4.17.21 tiny-invariant: specifier: 1.2.0 - version: 1.3.3 + version: 1.2.0 devDependencies: '@babel/core': specifier: 7.19.6 - version: 7.26.0 + version: 7.19.6 '@reactive-forms/core': specifier: workspace:* version: link:../core/prepared-package @@ -74,28 +74,28 @@ importers: version: link:../../tools/eslint-config '@types/react': specifier: 18.0.23 - version: 18.3.12 + version: 18.0.23 aqu: specifier: 0.4.3 - version: 0.4.3(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(@types/node@22.8.1)(babel-jest@29.7.0(@babel/core@7.26.0)) + version: 0.4.3(@babel/core@7.19.6)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(babel-plugin-macros@3.1.0) eslint: specifier: ^9.13.0 version: 9.13.0(jiti@2.3.3) jest: specifier: 29.2.2 - version: 29.7.0(@types/node@22.8.1) + version: 29.2.2(babel-plugin-macros@3.1.0) react: specifier: 18.2.0 - version: 18.3.1 + version: 18.2.0 rimraf: specifier: 3.0.2 - version: 6.0.1 + version: 3.0.2 tslib: specifier: 2.3.1 - version: 2.8.0 + version: 2.3.1 typescript: specifier: 4.8.4 - version: 5.6.3 + version: 4.8.4 publishDirectory: prepared-package packages/core: @@ -105,85 +105,85 @@ importers: version: 4.17.21 lodash-es: specifier: 4.17.15 - version: 4.17.21 + version: 4.17.15 pxth: - specifier: 0.7.0 - version: 0.7.0 + specifier: workspace:* + version: link:../pxth stocked: - specifier: 1.0.0-beta.33 - version: 1.0.0-beta.33(react@18.3.1) + specifier: workspace:* + version: link:../stocked tiny-invariant: specifier: 1.2.0 - version: 1.3.3 + version: 1.2.0 devDependencies: '@babel/core': specifier: 7.19.6 - version: 7.26.0 + version: 7.19.6 '@reactive-tools/eslint-config': specifier: workspace:* version: link:../../tools/eslint-config '@testing-library/react': specifier: 13.4.0 - version: 16.0.1(@testing-library/dom@8.19.0)(@types/react-dom@18.3.1)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1) + version: 13.4.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0) '@types/jest': specifier: 26.0.24 - version: 29.5.14 + version: 26.0.24 '@types/lodash': specifier: 4.14.161 - version: 4.17.12 + version: 4.14.161 '@types/node': specifier: ^18.11.18 - version: 22.8.1 + version: 18.19.60 '@types/react': specifier: 18.0.23 - version: 18.3.12 + version: 18.0.23 aqu: specifier: 0.4.3 - version: 0.4.3(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(@types/node@22.8.1)(babel-jest@29.7.0(@babel/core@7.26.0)) + version: 0.4.3(@babel/core@7.19.6)(@jest/transform@29.7.0)(@jest/types@29.6.3)(@types/node@18.19.60)(babel-jest@29.7.0(@babel/core@7.19.6))(babel-plugin-macros@3.1.0) eslint: specifier: ^9.13.0 version: 9.13.0(jiti@2.3.3) jest: specifier: 29.2.2 - version: 29.7.0(@types/node@22.8.1) + version: 29.2.2(@types/node@18.19.60)(babel-plugin-macros@3.1.0) react: specifier: 18.2.0 - version: 18.3.1 + version: 18.2.0 react-dom: specifier: 18.2.0 - version: 18.3.1(react@18.3.1) + version: 18.2.0(react@18.2.0) rimraf: specifier: 3.0.2 - version: 6.0.1 + version: 3.0.2 ts-jest: specifier: 29.0.3 - version: 29.2.5(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.0))(esbuild@0.15.18)(jest@29.7.0(@types/node@22.8.1))(typescript@5.6.3) + version: 29.0.3(@babel/core@7.19.6)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(jest@29.2.2(@types/node@18.19.60)(babel-plugin-macros@3.1.0))(typescript@4.8.4) tslib: specifier: 2.3.1 - version: 2.8.0 + version: 2.3.1 typescript: specifier: 4.8.4 - version: 5.6.3 + version: 4.8.4 yup: specifier: 0.32.9 - version: 1.4.0 + version: 0.32.9 publishDirectory: prepared-package packages/dom: dependencies: pxth: - specifier: 0.7.0 - version: 0.7.0 + specifier: workspace:* + version: link:../pxth stocked: - specifier: 1.0.0-beta.33 - version: 1.0.0-beta.33(react@18.3.1) + specifier: workspace:* + version: link:../stocked tiny-invariant: specifier: 1.2.0 - version: 1.3.3 + version: 1.2.0 devDependencies: '@babel/core': specifier: 7.19.6 - version: 7.26.0 + version: 7.19.6 '@reactive-forms/core': specifier: workspace:* version: link:../core/prepared-package @@ -192,19 +192,19 @@ importers: version: link:../../tools/eslint-config '@testing-library/react': specifier: 13.4.0 - version: 16.0.1(@testing-library/dom@8.19.0)(@types/react-dom@18.3.1)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1) + version: 13.4.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0) '@types/jest': specifier: 26.0.24 - version: 29.5.14 + version: 26.0.24 '@types/react': specifier: 18.0.23 - version: 18.3.12 + version: 18.0.23 '@types/react-dom': specifier: 18.0.6 - version: 18.3.1 + version: 18.0.6 aqu: specifier: 0.4.3 - version: 0.4.3(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(@types/node@22.8.1)(babel-jest@29.7.0(@babel/core@7.26.0)) + version: 0.4.3(@babel/core@7.19.6)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(babel-plugin-macros@3.1.0) cpy-cli: specifier: ^5.0.0 version: 5.0.0 @@ -213,28 +213,28 @@ importers: version: 9.13.0(jiti@2.3.3) jest: specifier: 29.2.2 - version: 29.7.0(@types/node@22.8.1) + version: 29.2.2(babel-plugin-macros@3.1.0) jest-environment-jsdom: specifier: 29.2.1 - version: 29.7.0 + version: 29.2.1 react: specifier: 18.2.0 - version: 18.3.1 + version: 18.2.0 react-dom: specifier: 18.2.0 - version: 18.3.1(react@18.3.1) + version: 18.2.0(react@18.2.0) rimraf: specifier: 3.0.2 - version: 6.0.1 + version: 3.0.2 ts-jest: specifier: 29.0.3 - version: 29.2.5(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.0))(esbuild@0.15.18)(jest@29.7.0(@types/node@22.8.1))(typescript@5.6.3) + version: 29.0.3(@babel/core@7.19.6)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(jest@29.2.2(babel-plugin-macros@3.1.0))(typescript@4.8.4) tslib: specifier: 2.3.1 - version: 2.8.0 + version: 2.3.1 typescript: specifier: 4.8.4 - version: 5.6.3 + version: 4.8.4 publishDirectory: prepared-package packages/pxth: @@ -251,13 +251,13 @@ importers: version: 0.16.4 '@microsoft/api-extractor': specifier: ^7.47.11 - version: 7.47.11(@types/node@22.8.1) + version: 7.47.11(@types/node@20.17.2) '@types/lodash': specifier: ^4.17.12 version: 4.17.12 '@types/node': - specifier: ^14.14.31 - version: 22.8.1 + specifier: ^20.17.2 + version: 20.17.2 eslint: specifier: ^9.13.0 version: 9.13.0(jiti@2.3.3) @@ -266,13 +266,68 @@ importers: version: 10.0.7(typescript@5.6.3) tsup: specifier: ^8.3.5 - version: 8.3.5(@microsoft/api-extractor@7.47.11(@types/node@22.8.1))(jiti@2.3.3)(postcss@8.4.47)(typescript@5.6.3) + version: 8.3.5(@microsoft/api-extractor@7.47.11(@types/node@20.17.2))(jiti@2.3.3)(postcss@8.4.47)(typescript@5.6.3) + typescript: + specifier: ^5.6.3 + version: 5.6.3 + vitest: + specifier: ^2.1.3 + version: 2.1.4(@types/node@20.17.2)(happy-dom@15.7.4)(jsdom@25.0.1) + + packages/stocked: + dependencies: + lodash: + specifier: ^4.17.21 + version: 4.17.21 + pxth: + specifier: workspace:* + version: link:../pxth + tiny-invariant: + specifier: ^1.3.3 + version: 1.3.3 + devDependencies: + '@testing-library/dom': + specifier: ^10.4.0 + version: 10.4.0 + '@testing-library/react': + specifier: ^16.0.1 + version: 16.0.1(@testing-library/dom@10.4.0)(@types/react-dom@18.3.1)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1) + '@types/lodash': + specifier: ^4.17.12 + version: 4.17.12 + '@types/react': + specifier: 18.3.12 + version: 18.3.12 + '@types/react-dom': + specifier: 18.3.1 + version: 18.3.1 + aqu: + specifier: ^0.4.3 + version: 0.4.3(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(@types/node@22.8.2)(babel-jest@29.7.0(@babel/core@7.26.0)) + configs: + specifier: github:fracht/configs + version: https://codeload.github.com/fracht/configs/tar.gz/b8a8e13fc3db0f3d5afdcedd0749fccc7292be30 + jsdom: + specifier: ^25.0.1 + version: 25.0.1 + react: + specifier: ^18.3.1 + version: 18.3.1 + react-dom: + specifier: ^18.3.1 + version: 18.3.1(react@18.3.1) + tslib: + specifier: 2.3.1 + version: 2.3.1 typescript: specifier: ^5.6.3 version: 5.6.3 + vitepress: + specifier: ^1.4.1 + version: 1.4.1(@algolia/client-search@4.24.0)(@types/node@22.8.2)(@types/react@18.3.12)(postcss@8.4.47)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(search-insights@2.17.2)(typescript@5.6.3) vitest: specifier: ^2.1.3 - version: 2.1.4(@types/node@22.8.1)(jsdom@20.0.3) + version: 2.1.4(@types/node@22.8.2)(happy-dom@15.7.4)(jsdom@25.0.1) packages/x: dependencies: @@ -282,7 +337,7 @@ importers: devDependencies: '@babel/core': specifier: 7.19.6 - version: 7.26.0 + version: 7.19.6 '@reactive-forms/core': specifier: workspace:* version: link:../core/prepared-package @@ -291,46 +346,46 @@ importers: version: link:../../tools/eslint-config '@testing-library/react': specifier: 13.4.0 - version: 16.0.1(@testing-library/dom@8.19.0)(@types/react-dom@18.3.1)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1) + version: 13.4.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0) '@types/jest': specifier: 26.0.24 - version: 29.5.14 + version: 26.0.24 '@types/lodash': specifier: 4.14.161 - version: 4.17.12 + version: 4.14.161 '@types/react': specifier: 18.0.23 - version: 18.3.12 + version: 18.0.23 '@types/react-dom': specifier: 18.0.6 - version: 18.3.1 + version: 18.0.6 aqu: specifier: 0.4.3 - version: 0.4.3(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(@types/node@22.8.1)(babel-jest@29.7.0(@babel/core@7.26.0)) + version: 0.4.3(@babel/core@7.19.6)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(babel-plugin-macros@3.1.0) eslint: specifier: ^9.13.0 version: 9.13.0(jiti@2.3.3) jest: specifier: 29.2.2 - version: 29.7.0(@types/node@22.8.1) + version: 29.2.2(babel-plugin-macros@3.1.0) react: specifier: 18.2.0 - version: 18.3.1 + version: 18.2.0 react-dom: specifier: 18.2.0 - version: 18.3.1(react@18.3.1) + version: 18.2.0(react@18.2.0) rimraf: specifier: 3.0.2 - version: 6.0.1 + version: 3.0.2 ts-jest: specifier: 29.0.3 - version: 29.2.5(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.0))(esbuild@0.15.18)(jest@29.7.0(@types/node@22.8.1))(typescript@5.6.3) + version: 29.0.3(@babel/core@7.19.6)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(jest@29.2.2(babel-plugin-macros@3.1.0))(typescript@4.8.4) tslib: specifier: 2.3.1 - version: 2.8.0 + version: 2.3.1 typescript: specifier: 4.8.4 - version: 5.6.3 + version: 4.8.4 publishDirectory: prepared-package tools/eslint-config: @@ -377,6 +432,71 @@ importers: packages: + '@algolia/autocomplete-core@1.9.3': + resolution: {integrity: sha512-009HdfugtGCdC4JdXUbVJClA0q0zh24yyePn+KUGk3rP7j8FEe/m5Yo/z65gn6nP/cM39PxpzqKrL7A6fP6PPw==} + + '@algolia/autocomplete-plugin-algolia-insights@1.9.3': + resolution: {integrity: sha512-a/yTUkcO/Vyy+JffmAnTWbr4/90cLzw+CC3bRbhnULr/EM0fGNvM13oQQ14f2moLMcVDyAx/leczLlAOovhSZg==} + peerDependencies: + search-insights: '>= 1 < 3' + + '@algolia/autocomplete-preset-algolia@1.9.3': + resolution: {integrity: sha512-d4qlt6YmrLMYy95n5TB52wtNDr6EgAIPH81dvvvW8UmuWRgxEtY0NJiPwl/h95JtG2vmRM804M0DSwMCNZlzRA==} + peerDependencies: + '@algolia/client-search': '>= 4.9.1 < 6' + algoliasearch: '>= 4.9.1 < 6' + + '@algolia/autocomplete-shared@1.9.3': + resolution: {integrity: sha512-Wnm9E4Ye6Rl6sTTqjoymD+l8DjSTHsHboVRYrKgEt8Q7UHm9nYbqhN/i0fhUYA3OAEH7WA8x3jfpnmJm3rKvaQ==} + peerDependencies: + '@algolia/client-search': '>= 4.9.1 < 6' + algoliasearch: '>= 4.9.1 < 6' + + '@algolia/cache-browser-local-storage@4.24.0': + resolution: {integrity: sha512-t63W9BnoXVrGy9iYHBgObNXqYXM3tYXCjDSHeNwnsc324r4o5UiVKUiAB4THQ5z9U5hTj6qUvwg/Ez43ZD85ww==} + + '@algolia/cache-common@4.24.0': + resolution: {integrity: sha512-emi+v+DmVLpMGhp0V9q9h5CdkURsNmFC+cOS6uK9ndeJm9J4TiqSvPYVu+THUP8P/S08rxf5x2P+p3CfID0Y4g==} + + '@algolia/cache-in-memory@4.24.0': + resolution: {integrity: sha512-gDrt2so19jW26jY3/MkFg5mEypFIPbPoXsQGQWAi6TrCPsNOSEYepBMPlucqWigsmEy/prp5ug2jy/N3PVG/8w==} + + '@algolia/client-account@4.24.0': + resolution: {integrity: sha512-adcvyJ3KjPZFDybxlqnf+5KgxJtBjwTPTeyG2aOyoJvx0Y8dUQAEOEVOJ/GBxX0WWNbmaSrhDURMhc+QeevDsA==} + + '@algolia/client-analytics@4.24.0': + resolution: {integrity: sha512-y8jOZt1OjwWU4N2qr8G4AxXAzaa8DBvyHTWlHzX/7Me1LX8OayfgHexqrsL4vSBcoMmVw2XnVW9MhL+Y2ZDJXg==} + + '@algolia/client-common@4.24.0': + resolution: {integrity: sha512-bc2ROsNL6w6rqpl5jj/UywlIYC21TwSSoFHKl01lYirGMW+9Eek6r02Tocg4gZ8HAw3iBvu6XQiM3BEbmEMoiA==} + + '@algolia/client-personalization@4.24.0': + resolution: {integrity: sha512-l5FRFm/yngztweU0HdUzz1rC4yoWCFo3IF+dVIVTfEPg906eZg5BOd1k0K6rZx5JzyyoP4LdmOikfkfGsKVE9w==} + + '@algolia/client-search@4.24.0': + resolution: {integrity: sha512-uRW6EpNapmLAD0mW47OXqTP8eiIx5F6qN9/x/7HHO6owL3N1IXqydGwW5nhDFBrV+ldouro2W1VX3XlcUXEFCA==} + + '@algolia/logger-common@4.24.0': + resolution: {integrity: sha512-LLUNjkahj9KtKYrQhFKCzMx0BY3RnNP4FEtO+sBybCjJ73E8jNdaKJ/Dd8A/VA4imVHP5tADZ8pn5B8Ga/wTMA==} + + '@algolia/logger-console@4.24.0': + resolution: {integrity: sha512-X4C8IoHgHfiUROfoRCV+lzSy+LHMgkoEEU1BbKcsfnV0i0S20zyy0NLww9dwVHUWNfPPxdMU+/wKmLGYf96yTg==} + + '@algolia/recommend@4.24.0': + resolution: {integrity: sha512-P9kcgerfVBpfYHDfVZDvvdJv0lEoCvzNlOy2nykyt5bK8TyieYyiD0lguIJdRZZYGre03WIAFf14pgE+V+IBlw==} + + '@algolia/requester-browser-xhr@4.24.0': + resolution: {integrity: sha512-Z2NxZMb6+nVXSjF13YpjYTdvV3032YTBSGm2vnYvYPA6mMxzM3v5rsCiSspndn9rzIW4Qp1lPHBvuoKJV6jnAA==} + + '@algolia/requester-common@4.24.0': + resolution: {integrity: sha512-k3CXJ2OVnvgE3HMwcojpvY6d9kgKMPRxs/kVohrwF5WMr2fnqojnycZkxPoEg+bXm8fi5BBfFmOqgYztRtHsQA==} + + '@algolia/requester-node-http@4.24.0': + resolution: {integrity: sha512-JF18yTjNOVYvU/L3UosRcvbPMGT9B+/GQWNWnenIImglzNVGpyzChkXLnrSf6uxwVNO6ESGu6oN8MqcGQcjQJw==} + + '@algolia/transporter@4.24.0': + resolution: {integrity: sha512-86nI7w6NzWxd1Zp9q3413dRshDqAzSbsQjhcDhPIatEFiZrL1/TjnHL8S7jVKFePlIMzDsZWXAXwXzcok9c5oA==} + '@ampproject/remapping@2.3.0': resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} engines: {node: '>=6.0.0'} @@ -401,6 +521,10 @@ packages: resolution: {integrity: sha512-qETICbZSLe7uXv9VE8T/RWOdIE5qqyTucOt4zLYMafj2MRO271VGgLd4RACJMeBO37UPWhXiKMBk7YlJ0fOzQA==} engines: {node: '>=6.9.0'} + '@babel/core@7.19.6': + resolution: {integrity: sha512-D2Ue4KHpc6Ys2+AxpIx1BZ8+UegLLLE2p3KJEuJRKmokHOtl49jQ5ny1773KsGLZs8MQvBidAF6yWUJxRqtKtg==} + engines: {node: '>=6.9.0'} + '@babel/core@7.26.0': resolution: {integrity: sha512-i1SLeK+DzNnQ3LL/CswPCa/E5u4lh1k6IAEphON8F+cXt0t9euTshDru0q7/IqMa1PMPz5RnHuHscF8/ZJsStg==} engines: {node: '>=6.9.0'} @@ -1063,6 +1187,29 @@ packages: resolution: {integrity: sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==} engines: {node: '>=0.1.90'} + '@docsearch/css@3.6.2': + resolution: {integrity: sha512-vKNZepO2j7MrYBTZIGXvlUOIR+v9KRf70FApRgovWrj3GTs1EITz/Xb0AOlm1xsQBp16clVZj1SY/qaOJbQtZw==} + + '@docsearch/js@3.6.2': + resolution: {integrity: sha512-pS4YZF+VzUogYrkblCucQ0Oy2m8Wggk8Kk7lECmZM60hTbaydSIhJTTiCrmoxtBqV8wxORnOqcqqOfbmkkQEcA==} + + '@docsearch/react@3.6.2': + resolution: {integrity: sha512-rtZce46OOkVflCQH71IdbXSFK+S8iJZlUF56XBW5rIgx/eG5qoomC7Ag3anZson1bBac/JFQn7XOBfved/IMRA==} + peerDependencies: + '@types/react': '>= 16.8.0 < 19.0.0' + react: '>= 16.8.0 < 19.0.0' + react-dom: '>= 16.8.0 < 19.0.0' + search-insights: '>= 1 < 3' + peerDependenciesMeta: + '@types/react': + optional: true + react: + optional: true + react-dom: + optional: true + search-insights: + optional: true + '@effect/schema@0.71.1': resolution: {integrity: sha512-XvFttkuBUL3s4ofZ+OVE4Pagb4wsPG8laSS8iO5lVI9Yt1zIM49uxlYIA2BJ45jjS3MdplUepC0NilotKnjU2A==} peerDependencies: @@ -1533,6 +1680,10 @@ packages: resolution: {integrity: sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + '@jest/types@26.6.2': + resolution: {integrity: sha512-fC6QCp7Sc5sX6g8Tvbmj4XUTbyrik0akgRy03yjXbQaBWWNWGE7SGtJk98m0N8nzegD/7SggrUlivxo5ax4KWQ==} + engines: {node: '>= 10.14.2'} + '@jest/types@29.6.3': resolution: {integrity: sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} @@ -1549,9 +1700,6 @@ packages: resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} engines: {node: '>=6.0.0'} - '@jridgewell/sourcemap-codec@1.4.15': - resolution: {integrity: sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==} - '@jridgewell/sourcemap-codec@1.5.0': resolution: {integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==} @@ -1805,6 +1953,24 @@ packages: zen-observable: optional: true + '@shikijs/core@1.22.2': + resolution: {integrity: sha512-bvIQcd8BEeR1yFvOYv6HDiyta2FFVePbzeowf5pPS1avczrPK+cjmaxxh0nx5QzbON7+Sv0sQfQVciO7bN72sg==} + + '@shikijs/engine-javascript@1.22.2': + resolution: {integrity: sha512-iOvql09ql6m+3d1vtvP8fLCVCK7BQD1pJFmHIECsujB0V32BJ0Ab6hxk1ewVSMFA58FI0pR2Had9BKZdyQrxTw==} + + '@shikijs/engine-oniguruma@1.22.2': + resolution: {integrity: sha512-GIZPAGzQOy56mGvWMoZRPggn0dTlBf1gutV5TdceLCZlFNqWmuc7u+CzD0Gd9vQUTgLbrt0KLzz6FNprqYAxlA==} + + '@shikijs/transformers@1.22.2': + resolution: {integrity: sha512-8f78OiBa6pZDoZ53lYTmuvpFPlWtevn23bzG+azpPVvZg7ITax57o/K3TC91eYL3OMJOO0onPbgnQyZjRos8XQ==} + + '@shikijs/types@1.22.2': + resolution: {integrity: sha512-NCWDa6LGZqTuzjsGfXOBWfjS/fDIbDdmVDug+7ykVe1IKT4c1gakrvlfFYp5NhAXH/lyqLM8wsAPo5wNy73Feg==} + + '@shikijs/vscode-textmate@9.3.0': + resolution: {integrity: sha512-jn7/7ky30idSkd/O5yDBfAnVt+JJpepofP/POZ1iMOxK59cOfqIgg/Dj0eFsjOTMw+4ycJN0uhZH/Eb0bs/EUA==} + '@sinclair/typebox@0.27.8': resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} @@ -1839,10 +2005,21 @@ packages: peerDependencies: size-limit: 11.1.6 + '@testing-library/dom@10.4.0': + resolution: {integrity: sha512-pemlzrSESWbdAloYml3bAJMEfNh1Z7EduzqPKprCH5S341frlpYnUEW0H72dLxa6IsYr+mPno20GiSm+h9dEdQ==} + engines: {node: '>=18'} + '@testing-library/dom@8.19.0': resolution: {integrity: sha512-6YWYPPpxG3e/xOo6HIWwB/58HukkwIVTOaZ0VwdMVjhRUX/01E4FtQbck9GazOOj7MXHc5RBzMrU86iBJHbI+A==} engines: {node: '>=12'} + '@testing-library/react@13.4.0': + resolution: {integrity: sha512-sXOGON+WNTh3MLE9rve97ftaZukN3oNf2KjDy7YTx6hcTO2uuLHuCGynMDhFwGw/jYf4OJ2Qk0i4i79qMNNkyw==} + engines: {node: '>=12'} + peerDependencies: + react: ^18.0.0 + react-dom: ^18.0.0 + '@testing-library/react@16.0.1': resolution: {integrity: sha512-dSmwJVtJXmku+iocRhWOUFbrERC76TX2Mnf0ATODz8brzAZrMBbzLwQixlBSanZxR6LddK3eiwpSFZgDET1URg==} engines: {node: '>=18'} @@ -1868,6 +2045,9 @@ packages: '@types/aria-query@4.2.2': resolution: {integrity: sha512-HnYpAE1Y6kRyKM/XkEuiRQhTHvkzMBurTHnpFLYLBGPIylZNPs9jJcuOOYWxPLJCSEtmZT0Y8rHDokKN7rRTig==} + '@types/aria-query@5.0.4': + resolution: {integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==} + '@types/babel__core@7.20.5': resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==} @@ -1886,6 +2066,9 @@ packages: '@types/graceful-fs@4.1.9': resolution: {integrity: sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==} + '@types/hast@3.0.4': + resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==} + '@types/istanbul-lib-coverage@2.0.6': resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==} @@ -1895,8 +2078,8 @@ packages: '@types/istanbul-reports@3.0.4': resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==} - '@types/jest@29.5.14': - resolution: {integrity: sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ==} + '@types/jest@26.0.24': + resolution: {integrity: sha512-E/X5Vib8BWqZNRlDxj9vYXhsDwPYbPINqKF9BsnSoon4RQ0D9moEuLD8txgyypFLH7J4+Lho9Nr/c8H0Fi+17w==} '@types/jsdom@20.0.1': resolution: {integrity: sha512-d0r18sZPmMQr1eG35u12FZfhIXNrnsPU/g5wvRKCUf/tOGilKKwYMYGqh33BNR6ba+2gkHw1EUiHoN3mn7E5IQ==} @@ -1904,30 +2087,63 @@ packages: '@types/json-schema@7.0.15': resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} + '@types/linkify-it@5.0.0': + resolution: {integrity: sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==} + + '@types/lodash@4.14.161': + resolution: {integrity: sha512-EP6O3Jkr7bXvZZSZYlsgt5DIjiGr0dXP1/jVEwVLTFgg0d+3lWVQkRavYVQszV7dYUwvg0B8R0MBDpcmXg7XIA==} + '@types/lodash@4.17.12': resolution: {integrity: sha512-sviUmCE8AYdaF/KIHLDJBQgeYzPBI0vf/17NaYehBJfYD1j6/L95Slh07NlyK2iNyBNaEkb3En2jRt+a8y3xZQ==} + '@types/markdown-it@14.1.2': + resolution: {integrity: sha512-promo4eFwuiW+TfGxhi+0x3czqTYJkG8qB17ZUJiVF10Xm7NLVRSLUsfRTU/6h1e24VvRnXCx+hG7li58lkzog==} + + '@types/mdast@4.0.4': + resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==} + + '@types/mdurl@2.0.0': + resolution: {integrity: sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==} + '@types/node@12.20.55': resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==} - '@types/node@22.8.1': - resolution: {integrity: sha512-k6Gi8Yyo8EtrNtkHXutUu2corfDf9su95VYVP10aGYMMROM6SAItZi0w1XszA6RtWTHSVp5OeFof37w0IEqCQg==} + '@types/node@18.19.60': + resolution: {integrity: sha512-cYRj7igVqgxhlHFdBHHpU2SNw3+dN2x0VTZJtLYk6y/ieuGN4XiBgtDjYVktM/yk2y/8pKMileNc6IoEzEJnUw==} + + '@types/node@20.17.2': + resolution: {integrity: sha512-OOHK4sjXqkL7yQ7VEEHcf6+0jSvKjWqwnaCtY7AKD/VLEvRHMsxxu7eI8ErnjxHS8VwmekD4PeVCpu4qZEZSxg==} + + '@types/node@22.8.2': + resolution: {integrity: sha512-NzaRNFV+FZkvK/KLCsNdTvID0SThyrs5SHB6tsD/lajr22FGC73N2QeDPM2wHtVde8mgcXuSsHQkH5cX1pbPLw==} '@types/normalize-package-data@2.4.4': resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==} + '@types/parse-json@4.0.2': + resolution: {integrity: sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==} + '@types/prop-types@15.7.13': resolution: {integrity: sha512-hCZTSvwbzWGvhqxp/RqVqwU999pBf2vp7hzIjiYOsl8wqOmUxkQ6ddw1cV3l8811+kdUFus/q4d1Y3E3SyEifA==} + '@types/react-dom@18.0.6': + resolution: {integrity: sha512-/5OFZgfIPSwy+YuIBP/FgJnQnsxhZhjjrnxudMddeblOouIodEQ75X14Rr4wGSG/bknL+Omy9iWlLo1u/9GzAA==} + '@types/react-dom@18.3.1': resolution: {integrity: sha512-qW1Mfv8taImTthu4KoXgDfLuk4bydU6Q/TkADnDWWHwi4NX4BR+LWfTp2sVmTqRrsHvyDDTelgelxJ+SsejKKQ==} + '@types/react@18.0.23': + resolution: {integrity: sha512-R1wTULtCiJkudAN2DJGoYYySbGtOdzZyUWAACYinKdiQC8auxso4kLDUhQ7AJ2kh3F6A6z4v69U6tNY39hihVQ==} + '@types/react@18.3.12': resolution: {integrity: sha512-D2wOSq/d6Agt28q7rSI3jhU7G6aiuzljDGZ2hTZHIkrTLUI+AF3WMeKkEZ9nN2fkBAlcktT6vcZjDFiIhMYEQw==} '@types/resolve@1.20.6': resolution: {integrity: sha512-A4STmOXPhMUtHH+S6ymgE2GiBSMqf4oTvcQZMcHzokuTLVYzXTB8ttjcgxOVaAp2lGwEdzZ0J+cRbbeevQj1UQ==} + '@types/scheduler@0.23.0': + resolution: {integrity: sha512-YIoDCTH3Af6XM5VuwGG/QL/CJqga1Zm3NkU3HZ4ZHK2fRMPYP1VczsTUqtsf43PH/iJNVlPHAo2oWX7BSdB2Hw==} + '@types/semver@7.5.8': resolution: {integrity: sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==} @@ -1937,9 +2153,18 @@ packages: '@types/tough-cookie@4.0.5': resolution: {integrity: sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==} + '@types/unist@3.0.3': + resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==} + + '@types/web-bluetooth@0.0.20': + resolution: {integrity: sha512-g9gZnnXVq7gM7v3tJCWV/qw7w+KeOlSHAhgF9RytFyifW6AF61hdT2ucrYhPq9hLs5JIryeupHV3qGk95dH9ow==} + '@types/yargs-parser@21.0.3': resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==} + '@types/yargs@15.0.19': + resolution: {integrity: sha512-2XUaGVmyQjgyAZldf0D0c14vvo/yv0MhQBSTJcejMMaitsn3nxCB6TmH4G0ZQf+uxROOa9mpanoSm8h6SG/1ZA==} + '@types/yargs@17.0.33': resolution: {integrity: sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==} @@ -2061,6 +2286,13 @@ packages: '@ungap/structured-clone@1.2.0': resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==} + '@vitejs/plugin-vue@5.1.4': + resolution: {integrity: sha512-N2XSI2n3sQqp5w7Y/AN/L2XDjBIRGqXko+eDp42sydYSBeJuSm5a1sLf8zakmo8u7tA8NmBgoDLA1HeOESjp9A==} + engines: {node: ^18.0.0 || >=20.0.0} + peerDependencies: + vite: ^5.0.0 + vue: ^3.2.25 + '@vitest/expect@2.1.4': resolution: {integrity: sha512-DOETT0Oh1avie/D/o2sgMHGrzYUFFo3zqESB2Hn70z6QB1HrS2IQ9z5DfyTqU8sg4Bpu13zZe9V4+UTNQlUeQA==} @@ -2090,6 +2322,94 @@ packages: '@vitest/utils@2.1.4': resolution: {integrity: sha512-MXDnZn0Awl2S86PSNIim5PWXgIAx8CIkzu35mBdSApUip6RFOGXBCf3YFyeEu8n1IHk4bWD46DeYFu9mQlFIRg==} + '@vue/compiler-core@3.5.12': + resolution: {integrity: sha512-ISyBTRMmMYagUxhcpyEH0hpXRd/KqDU4ymofPgl2XAkY9ZhQ+h0ovEZJIiPop13UmR/54oA2cgMDjgroRelaEw==} + + '@vue/compiler-dom@3.5.12': + resolution: {integrity: sha512-9G6PbJ03uwxLHKQ3P42cMTi85lDRvGLB2rSGOiQqtXELat6uI4n8cNz9yjfVHRPIu+MsK6TE418Giruvgptckg==} + + '@vue/compiler-sfc@3.5.12': + resolution: {integrity: sha512-2k973OGo2JuAa5+ZlekuQJtitI5CgLMOwgl94BzMCsKZCX/xiqzJYzapl4opFogKHqwJk34vfsaKpfEhd1k5nw==} + + '@vue/compiler-ssr@3.5.12': + resolution: {integrity: sha512-eLwc7v6bfGBSM7wZOGPmRavSWzNFF6+PdRhE+VFJhNCgHiF8AM7ccoqcv5kBXA2eWUfigD7byekvf/JsOfKvPA==} + + '@vue/devtools-api@7.5.4': + resolution: {integrity: sha512-j9UC/KeYUNZ6AyCJxBROBCbogB5YHW6PZv9VnCNp2ntE4rq426Lfc8WP5B9V+rXBwqWmrgZTGYBa31CBSxdAUg==} + + '@vue/devtools-kit@7.5.4': + resolution: {integrity: sha512-0i7WFgc1B2TL52tstn82zlb9opSA0aIiHfkUYFXtZb8CIpmlFMTkHtgwVl6PMWNBj3LNhYou1YJCLpCYvJYYoA==} + + '@vue/devtools-shared@7.5.4': + resolution: {integrity: sha512-dwuq4YmwTyLc7eBOqX63s3JB8il7qnKsNgENglSMkUPwiItHkVAYYfPESN1rxSdYkl1RCux1l5TBidYqfUDNAA==} + + '@vue/reactivity@3.5.12': + resolution: {integrity: sha512-UzaN3Da7xnJXdz4Okb/BGbAaomRHc3RdoWqTzlvd9+WBR5m3J39J1fGcHes7U3za0ruYn/iYy/a1euhMEHvTAg==} + + '@vue/runtime-core@3.5.12': + resolution: {integrity: sha512-hrMUYV6tpocr3TL3Ad8DqxOdpDe4zuQY4HPY3X/VRh+L2myQO8MFXPAMarIOSGNu0bFAjh1yBkMPXZBqCk62Uw==} + + '@vue/runtime-dom@3.5.12': + resolution: {integrity: sha512-q8VFxR9A2MRfBr6/55Q3umyoN7ya836FzRXajPB6/Vvuv0zOPL+qltd9rIMzG/DbRLAIlREmnLsplEF/kotXKA==} + + '@vue/server-renderer@3.5.12': + resolution: {integrity: sha512-I3QoeDDeEPZm8yR28JtY+rk880Oqmj43hreIBVTicisFTx/Dl7JpG72g/X7YF8hnQD3IFhkky5i2bPonwrTVPg==} + peerDependencies: + vue: 3.5.12 + + '@vue/shared@3.5.12': + resolution: {integrity: sha512-L2RPSAwUFbgZH20etwrXyVyCBu9OxRSi8T/38QsvnkJyvq2LufW2lDCOzm7t/U9C1mkhJGWYfCuFBCmIuNivrg==} + + '@vueuse/core@11.1.0': + resolution: {integrity: sha512-P6dk79QYA6sKQnghrUz/1tHi0n9mrb/iO1WTMk/ElLmTyNqgDeSZ3wcDf6fRBGzRJbeG1dxzEOvLENMjr+E3fg==} + + '@vueuse/integrations@11.1.0': + resolution: {integrity: sha512-O2ZgrAGPy0qAjpoI2YR3egNgyEqwG85fxfwmA9BshRIGjV4G6yu6CfOPpMHAOoCD+UfsIl7Vb1bXJ6ifrHYDDA==} + peerDependencies: + async-validator: ^4 + axios: ^1 + change-case: ^5 + drauu: ^0.4 + focus-trap: ^7 + fuse.js: ^7 + idb-keyval: ^6 + jwt-decode: ^4 + nprogress: ^0.2 + qrcode: ^1.5 + sortablejs: ^1 + universal-cookie: ^7 + peerDependenciesMeta: + async-validator: + optional: true + axios: + optional: true + change-case: + optional: true + drauu: + optional: true + focus-trap: + optional: true + fuse.js: + optional: true + idb-keyval: + optional: true + jwt-decode: + optional: true + nprogress: + optional: true + qrcode: + optional: true + sortablejs: + optional: true + universal-cookie: + optional: true + + '@vueuse/metadata@11.1.0': + resolution: {integrity: sha512-l9Q502TBTaPYGanl1G+hPgd3QX5s4CGnpXriVBR5fEZ/goI6fvDaVmIl3Td8oKFurOxTmbXvBPSsgrd6eu6HYg==} + + '@vueuse/shared@11.1.0': + resolution: {integrity: sha512-YUtIpY122q7osj+zsNMFAfMTubGz0sn5QzE5gPzAIiCmtt2ha3uQUY1+JPyL4gRCTsLPX82Y9brNbo/aqlA91w==} + abab@2.0.6: resolution: {integrity: sha512-j2afSsaIENvHZN2B8GOpF566vZ5WVk5opAiMTvWgaQT8DkbOqsTfvNAvHoRGU2zzP8cPoqys+xHTRDWW8L+/BA==} deprecated: Use your platform's native atob() and btoa() methods instead @@ -2115,6 +2435,10 @@ packages: resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} engines: {node: '>= 6.0.0'} + agent-base@7.1.1: + resolution: {integrity: sha512-H0TSyFNDMomMNJQBn8wFV5YC/2eJ+VXECwOadZJT554xP6cODZHPX3H9QMQECxvrgiSOP1pHjy1sMWQVYJOUOA==} + engines: {node: '>= 14'} + aggregate-error@4.0.1: resolution: {integrity: sha512-0poP0T7el6Vq3rstR8Mn4V/IQrpBLO6POkUSrN7RhyY+GF/InCFShQzsQ39T25gkHhLgSLByyAz+Kjb+c2L98w==} engines: {node: '>=12'} @@ -2144,6 +2468,9 @@ packages: ajv@8.13.0: resolution: {integrity: sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA==} + algoliasearch@4.24.0: + resolution: {integrity: sha512-bf0QV/9jVejssFBmz2HQLxUadxk574t4iwjCKp5E7NBzwKkrDEhKPISIIjAU/p6K5qDx3qoeh4+26zWN1jmw3g==} + ansi-align@3.0.1: resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==} @@ -2241,6 +2568,9 @@ packages: argparse@2.0.1: resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + aria-query@5.3.0: + resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==} + aria-query@5.3.2: resolution: {integrity: sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==} engines: {node: '>= 0.4'} @@ -2315,6 +2645,10 @@ packages: resolution: {integrity: sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + babel-plugin-macros@3.1.0: + resolution: {integrity: sha512-Cg7TFGpIr01vOQNODXOOaGz2NpCU5gl8x1qJFbb6hbZxR7XrcE2vtbAsTAbJ7/xwJtUuJEw8K8Zr/AE0LHlesg==} + engines: {node: '>=10', npm: '>=6'} + babel-plugin-polyfill-corejs2@0.4.11: resolution: {integrity: sha512-sMEJ27L0gRHShOh5G54uAAPaiCOygY/5ratXuiyb2G46FmlSpc9eFCzYVyDiPxfNbwzA7mYahmjQc5q+CZQ09Q==} peerDependencies: @@ -2361,6 +2695,9 @@ packages: resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==} engines: {node: '>=8'} + birpc@0.2.19: + resolution: {integrity: sha512-5WeXXAvTmitV1RqJFppT5QtUiz2p1mRSYU000Jkft5ZUCLJIk4uQriYNO50HknxKwM6jd8utNc66K1qGIwwWBQ==} + bl@4.1.0: resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} @@ -2440,6 +2777,9 @@ packages: caniuse-lite@1.0.30001673: resolution: {integrity: sha512-WTrjUCSMp3LYX0nE12ECkV0a+e6LC85E0Auz75555/qr78Oc8YWhEPNfDd6SHdtlCMSzqtuXY0uyEMNRcsKpKw==} + ccount@2.0.1: + resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==} + chai@5.1.2: resolution: {integrity: sha512-aGtmf24DW6MLHHG5gCx4zaI3uBq3KRtxeVs0DjFH6Z0rDNbsvTxFASFvdj79pxjxZ8/5u3PIiN3IwEIQkiiuPw==} engines: {node: '>=12'} @@ -2472,6 +2812,12 @@ packages: resolution: {integrity: sha512-oSvEeo6ZUD7NepqAat3RqoucZ5SeqLJgOvVIwkafu6IP3V0pO38s/ypdVUmDDK6qIIHNlYHJAKX9E7R7HoKElw==} engines: {node: '>=12.20'} + character-entities-html4@2.1.0: + resolution: {integrity: sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==} + + character-entities-legacy@3.0.0: + resolution: {integrity: sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==} + chardet@0.7.0: resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==} @@ -2594,6 +2940,9 @@ packages: resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} engines: {node: '>= 0.8'} + comma-separated-tokens@2.0.3: + resolution: {integrity: sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==} + commander@10.0.1: resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==} engines: {node: '>=14'} @@ -2619,6 +2968,10 @@ packages: config-chain@1.1.13: resolution: {integrity: sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==} + configs@https://codeload.github.com/fracht/configs/tar.gz/b8a8e13fc3db0f3d5afdcedd0749fccc7292be30: + resolution: {tarball: https://codeload.github.com/fracht/configs/tar.gz/b8a8e13fc3db0f3d5afdcedd0749fccc7292be30} + version: 1.0.0 + configstore@7.0.0: resolution: {integrity: sha512-yk7/5PN5im4qwz0WFZW3PXnzHgPu9mX29Y8uZ3aefe2lBPC1FYttWZRcaW9fKkT0pBCJyuQ2HfbmPVaODi9jcQ==} engines: {node: '>=18'} @@ -2627,15 +2980,26 @@ packages: resolution: {integrity: sha512-I5qxpzLv+sJhTVEoLYNcTW+bThDCPsit0vLNKShZx6rLtpilNpmmeTPaeqJb9ZE9dV3DGaeby6Vuhrw38WjeyQ==} engines: {node: ^14.18.0 || >=16.10.0} + convert-source-map@1.9.0: + resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==} + convert-source-map@2.0.0: resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + copy-anything@3.0.5: + resolution: {integrity: sha512-yCEafptTtb4bk7GLEQoM8KVJpxAfdBJYaXyzQEgQQQgYrZiDp8SJmGKlYza6CYjEDNstAdNdKA3UuoULlEbS6w==} + engines: {node: '>=12.13'} + core-js-compat@3.38.1: resolution: {integrity: sha512-JRH6gfXxGmrzF3tZ57lFx97YARxCXPaMzPo6jELZhv88pBH5VXpQ+y0znKGlFnzuaihqhLbefxSJxWJMPtfDzw==} core-js@3.38.1: resolution: {integrity: sha512-OP35aUorbU3Zvlx7pjsFdu1rGNnD4pgw/CWoYzRY3t2EzoVT7shKHY1dlAy3f41cGIO7ZDPQimhGFTlEYkG/Hw==} + cosmiconfig@7.1.0: + resolution: {integrity: sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==} + engines: {node: '>=10'} + cosmiconfig@8.3.6: resolution: {integrity: sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==} engines: {node: '>=14'} @@ -2689,6 +3053,10 @@ packages: resolution: {integrity: sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A==} engines: {node: '>=8'} + cssstyle@4.1.0: + resolution: {integrity: sha512-h66W1URKpBS5YMI/V8PyXvTMFT8SupJ1IzoIV8IeBC/ji8WVmrO8dGlTi+2dh6whmdk6BiKJLD/ZBkhWbcg6nA==} + engines: {node: '>=18'} + csstype@3.1.3: resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==} @@ -2701,6 +3069,10 @@ packages: resolution: {integrity: sha512-Jy/tj3ldjZJo63sVAvg6LHt2mHvl4V6AgRAmNDtLdm7faqtsx+aJG42rsyCo9JCoRVKwPFzKlIPx3DIibwSIaQ==} engines: {node: '>=12'} + data-urls@5.0.0: + resolution: {integrity: sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==} + engines: {node: '>=18'} + data-view-buffer@1.0.1: resolution: {integrity: sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA==} engines: {node: '>= 0.4'} @@ -2785,6 +3157,10 @@ packages: deprecation@2.3.1: resolution: {integrity: sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==} + dequal@2.0.3: + resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} + engines: {node: '>=6'} + detect-indent@6.1.0: resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==} engines: {node: '>=8'} @@ -2793,6 +3169,13 @@ packages: resolution: {integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==} engines: {node: '>=8'} + devlop@1.1.0: + resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==} + + diff-sequences@26.6.2: + resolution: {integrity: sha512-Mv/TDa3nZ9sbc5soK+OoA74BsS3mL37yixCvUAQkiuA4Wz6YtwP/K47n2rv2ovzHZvoiQeA5FTQOschKkEwB0Q==} + engines: {node: '>= 10.14.2'} + diff-sequences@29.6.3: resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} @@ -3208,6 +3591,9 @@ packages: resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} engines: {node: '>=4.0'} + estree-walker@2.0.2: + resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==} + estree-walker@3.0.3: resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==} @@ -3352,6 +3738,9 @@ packages: flatted@3.3.1: resolution: {integrity: sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==} + focus-trap@7.6.0: + resolution: {integrity: sha512-1td0l3pMkWJLFipobUcGaf+5DTY4PLDDrcqoSaKP8ediO/CoWCCYk/fT/Y2A4e6TNB+Sh6clRJCjOPPnKoNHnQ==} + for-each@0.3.3: resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} @@ -3460,11 +3849,6 @@ packages: resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==} hasBin: true - glob@11.0.0: - resolution: {integrity: sha512-9UiX/Bl6J2yaBbxKoEBRm4Cipxgok8kQYcOPEhScPwebu2I0HoQOuYdIO6S3hLuWoZgpDpwQZMzTFxgpkyT76g==} - engines: {node: 20 || >=22} - hasBin: true - glob@7.2.3: resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} deprecated: Glob versions prior to v9 are no longer supported @@ -3513,6 +3897,10 @@ packages: graphemer@1.4.0: resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} + happy-dom@15.7.4: + resolution: {integrity: sha512-r1vadDYGMtsHAAsqhDuk4IpPvr6N8MGKy5ntBo7tSdim+pWDxus2PNqOcOt8LuDZ4t3KJHE+gCuzupcx/GKnyQ==} + engines: {node: '>=18.0.0'} + has-ansi@2.0.0: resolution: {integrity: sha512-C8vBJ8DwUCx19vhm7urhTuUsr4/IyP6l4VzNQDv+ryHQObW3TTTp9yB68WpYgRe2bbaGuZ/se74IqFeVnMnLZg==} engines: {node: '>=0.10.0'} @@ -3555,6 +3943,12 @@ packages: resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} engines: {node: '>= 0.4'} + hast-util-to-html@9.0.3: + resolution: {integrity: sha512-M17uBDzMJ9RPCqLMO92gNNUDuBSq10a25SDBI08iCCxmorf4Yy6sYHK57n9WAbRAAaU+DuR4W6GN9K4DFZesYg==} + + hast-util-whitespace@3.0.0: + resolution: {integrity: sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==} + highlight.js@10.7.3: resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==} @@ -3562,6 +3956,9 @@ packages: resolution: {integrity: sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==} engines: {node: '>=0.10.0'} + hookable@5.5.3: + resolution: {integrity: sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==} + hosted-git-info@7.0.2: resolution: {integrity: sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==} engines: {node: ^16.14.0 || >=18.0.0} @@ -3570,17 +3967,32 @@ packages: resolution: {integrity: sha512-oWv4T4yJ52iKrufjnyZPkrN0CH3QnrUqdB6In1g5Fe1mia8GmF36gnfNySxoZtxD5+NmYw1EElVXiBk93UeskA==} engines: {node: '>=12'} + html-encoding-sniffer@4.0.0: + resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==} + engines: {node: '>=18'} + html-escaper@2.0.2: resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} + html-void-elements@3.0.0: + resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==} + http-proxy-agent@5.0.0: resolution: {integrity: sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==} engines: {node: '>= 6'} + http-proxy-agent@7.0.2: + resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==} + engines: {node: '>= 14'} + https-proxy-agent@5.0.1: resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} engines: {node: '>= 6'} + https-proxy-agent@7.0.5: + resolution: {integrity: sha512-1e4Wqeblerz+tMKPIq2EMGiiWW1dIjZOksyHWSUm1rmuvw/how9hBHZ38lAGj5ID4Ik6EdkOw7NmWPy6LAwalw==} + engines: {node: '>= 14'} + human-id@1.0.2: resolution: {integrity: sha512-UNopramDEhHJD+VR+ehk8rOslwSfByxPIZyJRfV739NDhN5LF1fa1MqnzKm2lGTQRjNrjK19Q5fhkgIfjlVUKw==} @@ -3910,6 +4322,10 @@ packages: resolution: {integrity: sha512-LvIm3/KWzS9oRFHugab7d+M/GcBXuXX5xZkzPmN+NxihdQlZUQ4dWuSV1xR/sq6upL1TJEDrfBgRepHFdBtSNQ==} engines: {node: '>= 0.4'} + is-what@4.1.16: + resolution: {integrity: sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==} + engines: {node: '>=12.13'} + is-windows@1.0.2: resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==} engines: {node: '>=0.10.0'} @@ -3963,10 +4379,6 @@ packages: jackspeak@3.4.3: resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==} - jackspeak@4.0.2: - resolution: {integrity: sha512-bZsjR/iRjl1Nk1UkjGpAzLNfQtzuijhn2g+pbZb98HQ1Gk8vM9hfbxeMBP+M2/UUdwj0RqGG3mlvk2MsAqwvEw==} - engines: {node: 20 || >=22} - jake@10.9.2: resolution: {integrity: sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA==} engines: {node: '>=10'} @@ -4002,6 +4414,10 @@ packages: ts-node: optional: true + jest-diff@26.6.2: + resolution: {integrity: sha512-6m+9Z3Gv9wN0WFVasqjCL/06+EFCMTqDEUl/b87HYK2rAPTyfz4ZIuSlPhY51PIQRWx5TaxeF1qmXKe9gfN3sA==} + engines: {node: '>= 10.14.2'} + jest-diff@29.7.0: resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} @@ -4014,8 +4430,8 @@ packages: resolution: {integrity: sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - jest-environment-jsdom@29.7.0: - resolution: {integrity: sha512-k9iQbsf9OyOfdzWH8HDmrRT0gSIcX+FLNW7IQq94tFX0gynPwqDTW0Ho6iMVNjGz/nb+l/vW3dWM2bbLLpkbXA==} + jest-environment-jsdom@29.2.1: + resolution: {integrity: sha512-MipBdmrjgzEdQMkK7b7wBShOfv1VqO6FVwa9S43bZwKYLC4dlWnPiCgNpZX3ypNEpJO8EMpMhg4HrUkWUZXGiw==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} peerDependencies: canvas: ^2.5.0 @@ -4027,6 +4443,10 @@ packages: resolution: {integrity: sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + jest-get-type@26.3.0: + resolution: {integrity: sha512-TpfaviN1R2pQWkIihlfEanwOXK0zcxrKEE4MlU6Tn7keoXdN6/3gK/xl0yEh8DOunn5pOVGKf8hB4R9gVh04ig==} + engines: {node: '>= 10.14.2'} + jest-get-type@29.6.3: resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} @@ -4106,6 +4526,16 @@ packages: resolution: {integrity: sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + jest@29.2.2: + resolution: {integrity: sha512-r+0zCN9kUqoON6IjDdjbrsWobXM/09Nd45kIPRD8kloaRh1z5ZCMdVsgLXGxmlL7UpAJsvCYOQNO+NjvG/gqiQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + hasBin: true + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + jest@29.7.0: resolution: {integrity: sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} @@ -4147,6 +4577,15 @@ packages: canvas: optional: true + jsdom@25.0.1: + resolution: {integrity: sha512-8i7LzZj7BF8uplX+ZyOlIz86V6TAsSs+np6m1kpW9u0JWi4z/1t+FzcK1aek+ybTnAC4KhBL4uXCNT0wcUIeCw==} + engines: {node: '>=18'} + peerDependencies: + canvas: ^2.11.2 + peerDependenciesMeta: + canvas: + optional: true + jsesc@3.0.2: resolution: {integrity: sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==} engines: {node: '>=6'} @@ -4271,6 +4710,9 @@ packages: resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} engines: {node: '>=10'} + lodash-es@4.17.15: + resolution: {integrity: sha512-rlrc3yU3+JNOpZ9zj5pQtxnx2THmvRykwL4Xlxoa8I9lHBlVbbyPhgyPMioxVZ4NqyxaVVtaJnzsyOidQIhyyQ==} + lodash-es@4.17.21: resolution: {integrity: sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==} @@ -4313,6 +4755,9 @@ packages: lodash.merge@4.6.2: resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} + lodash.mergewith@4.6.2: + resolution: {integrity: sha512-GK3g5RPZWTRSeLSpgP8Xhra+pnjBC56q9FZYe1d5RN3TJ35dbkGy3YqBSMbyCrlbi+CM9Z3Jk5yTL7RCsqboyQ==} + lodash.once@4.1.1: resolution: {integrity: sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==} @@ -4354,10 +4799,6 @@ packages: lru-cache@10.4.3: resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==} - lru-cache@11.0.1: - resolution: {integrity: sha512-CgeuL5uom6j/ZVrg7G/+1IXqRY8JXX4Hghfy5YE0EhoYQWvndP1kufu58cmZLNIDKnRhZrXfdS9urVWx98AipQ==} - engines: {node: 20 || >=22} - lru-cache@4.1.5: resolution: {integrity: sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==} @@ -4385,6 +4826,9 @@ packages: makeerror@1.0.12: resolution: {integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==} + mark.js@8.11.1: + resolution: {integrity: sha512-1I+1qpDt4idfgLQG+BNWmrqku+7/2bi5nLf4YwF8y8zXvmfiTBY3PV3ZibfrjBueCByROpuBjLLFCajqkgYoLQ==} + marked-terminal@7.1.0: resolution: {integrity: sha512-+pvwa14KZL74MVXjYdPR3nSInhGhNvPce/3mqLVZT2oUvt654sL1XImFuLZ1pkA866IYZ3ikDTOFUIC7XzpZZg==} engines: {node: '>=16.0.0'} @@ -4396,6 +4840,9 @@ packages: engines: {node: '>= 16'} hasBin: true + mdast-util-to-hast@13.2.0: + resolution: {integrity: sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==} + memfs-or-file-map-to-github-branch@1.2.1: resolution: {integrity: sha512-I/hQzJ2a/pCGR8fkSQ9l5Yx+FQ4e7X6blNHyWBm2ojeFLT3GVzGkTj7xnyWpdclrr7Nq4dmx3xrvu70m3ypzAQ==} @@ -4414,6 +4861,21 @@ packages: resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} engines: {node: '>= 8'} + micromark-util-character@2.1.0: + resolution: {integrity: sha512-KvOVV+X1yLBfs9dCBSopq/+G1PcgT3lAK07mC4BzXi5E7ahzMAF8oIupDDJ6mievI6F+lAATkbQQlQixJfT3aQ==} + + micromark-util-encode@2.0.0: + resolution: {integrity: sha512-pS+ROfCXAGLWCOc8egcBvT0kf27GoWMqtdarNfDcjb6YLuV5cM3ioG45Ys2qOVqeqSbjaKg72vU+Wby3eddPsA==} + + micromark-util-sanitize-uri@2.0.0: + resolution: {integrity: sha512-WhYv5UEcZrbAtlsnPuChHUAsu/iBPOVaEVsntLBIdpibO0ddy8OzavZz3iL2xVvBZOpolujSliP65Kq0/7KIYw==} + + micromark-util-symbol@2.0.0: + resolution: {integrity: sha512-8JZt9ElZ5kyTnO94muPxIGS8oyElRJaiJO8EzV6ZSyGQ1Is8xwl4Q45qU5UOg+bGH4AikWziz0iN4sFLWs8PGw==} + + micromark-util-types@2.0.0: + resolution: {integrity: sha512-oNh6S2WMHWRZrmutsRmDDfkzKtxF+bc2VxLC9dvtrDIRFln627VsFP6fLMgTryGDljgLPjkrzQSDcPrjPyDJ5w==} + micromatch@4.0.8: resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} engines: {node: '>=8.6'} @@ -4442,10 +4904,6 @@ packages: resolution: {integrity: sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==} engines: {node: '>=18'} - minimatch@10.0.1: - resolution: {integrity: sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ==} - engines: {node: 20 || >=22} - minimatch@3.0.8: resolution: {integrity: sha512-6FsRAQsxQ61mw+qP1ZzbL9Bc78x2p5OqNgNpnoAFLTrX8n5Kxph0CsnhmKKNXTWjXqU5L0pGPR7hYk+XWZr60Q==} @@ -4467,6 +4925,12 @@ packages: resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==} engines: {node: '>=16 || 14 >=14.17'} + minisearch@7.1.0: + resolution: {integrity: sha512-tv7c/uefWdEhcu6hvrfTihflgeEi2tN6VV7HJnCjK6VxM75QQJh4t9FwJCsA2EsRS8LCnu3W87CuGPWMocOLCA==} + + mitt@3.0.1: + resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==} + mri@1.2.0: resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==} engines: {node: '>=4'} @@ -4621,6 +5085,9 @@ packages: resolution: {integrity: sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==} engines: {node: '>=18'} + oniguruma-to-js@0.4.3: + resolution: {integrity: sha512-X0jWUcAlxORhOqqBREgPMgnshB7ZGYszBNspP+tS9hPD3l13CdaXcHbgImoHUHlrvGx/7AvFEkTRhAGYh+jzjQ==} + open@10.1.0: resolution: {integrity: sha512-mnkeQ1qP5Ue2wd+aivTD3NHd/lZ96Lu0jgf0pwktLPtx6cTZiH7tyeGRRHs0zX0rbrahXPnXlUnbeXyaBBuIaw==} engines: {node: '>=18'} @@ -4791,10 +5258,6 @@ packages: resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==} engines: {node: '>=16 || 14 >=14.18'} - path-scurry@2.0.0: - resolution: {integrity: sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg==} - engines: {node: 20 || >=22} - path-type@4.0.0: resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} engines: {node: '>=8'} @@ -4810,6 +5273,9 @@ packages: resolution: {integrity: sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==} engines: {node: '>= 14.16'} + perfect-debounce@1.0.0: + resolution: {integrity: sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==} + picocolors@1.1.1: resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} @@ -4870,6 +5336,9 @@ packages: resolution: {integrity: sha512-56rxCq7G/XfB4EkXq9Egn5GCqugWvDFjafDOThIdMBsI15iqPqR5r15TfSr1YPYeEI19YeaXMCbY6u88Y76GLQ==} engines: {node: ^10 || ^12 || >=14} + preact@10.24.3: + resolution: {integrity: sha512-Z2dPnBnMUfyQfSQ+GBdsGa16hz35YmLmtTLhM169uW944hYL6xzTYkJjC07j+Wosz733pMWx0fgON3JNw1jJQA==} + prelude-ls@1.2.1: resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} engines: {node: '>= 0.8.0'} @@ -4888,6 +5357,10 @@ packages: engines: {node: '>=14'} hasBin: true + pretty-format@26.6.2: + resolution: {integrity: sha512-7AeGuCYNGmycyQbCqd/3PWH4eOoX/OiCa0uphp57NVTeAGdJGaAliecxwBDHYQCIvrW7aDBZCYeNTP/WX69mkg==} + engines: {node: '>= 10'} + pretty-format@27.5.1: resolution: {integrity: sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==} engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0} @@ -4914,6 +5387,9 @@ packages: property-expr@2.0.6: resolution: {integrity: sha512-SVtmxhRE/CGkn3eZY1T6pC8Nln6Fr/lu1mKSgRud0eC73whjGfoAogbn78LkD8aFL0zz3bAFerKSnOl7NlErBA==} + property-information@6.5.0: + resolution: {integrity: sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig==} + proto-list@1.2.4: resolution: {integrity: sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==} @@ -4937,9 +5413,6 @@ packages: pure-rand@6.1.0: resolution: {integrity: sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==} - pxth@0.7.0: - resolution: {integrity: sha512-V2bNJNl7FIuvjsnreT7EWaBiqD5akAuGrKAVxgarjmTSDcDIGKLhY39ZFBqMkSTN8OHEBM4pszNUN+rfrojMfw==} - qs@6.13.0: resolution: {integrity: sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==} engines: {node: '>=0.6'} @@ -4954,6 +5427,11 @@ packages: resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} hasBin: true + react-dom@18.2.0: + resolution: {integrity: sha512-6IMTriUmvsjHUjNtEDudZfuDQUoWXVxKHhlEGSk81n4YFS+r/Kl99wXiwlVXtPBtJenozv2P+hxDsw9eA7Xo6g==} + peerDependencies: + react: ^18.2.0 + react-dom@18.3.1: resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==} peerDependencies: @@ -4968,6 +5446,10 @@ packages: react-is@18.3.1: resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==} + react@18.2.0: + resolution: {integrity: sha512-/3IjMdb2L9QbBdWiW5e3P2/npwMBaU9mHCSCUzNln0ZCYbcfTsGbTJrU/kGemdH2IWmB2ioZ+zkxtmq6g09fGQ==} + engines: {node: '>=0.10.0'} + react@18.3.1: resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==} engines: {node: '>=0.10.0'} @@ -5024,6 +5506,9 @@ packages: regenerator-transform@0.15.2: resolution: {integrity: sha512-hfMp2BoF0qOk3uc5V20ALGDS2ddjQaLrdl7xrGXvAIow7qeWRM2VA2HuCHkUKk9slq3VwEwLNK3DFBqDfPGYtg==} + regex@4.3.3: + resolution: {integrity: sha512-r/AadFO7owAq1QJVeZ/nq9jNS1vyZt+6t1p/E59B56Rn2GCya+gr1KSyOzNL/er+r+B7phv5jG2xU2Nz1YkmJg==} + regexp.prototype.flags@1.5.3: resolution: {integrity: sha512-vqlC04+RQoFalODCbCumG2xIOvapzVMHwsyIGM/SIE8fRhFFsXeH8/QQ+s0T0kDAhKc4k30s73/0ydkHQz6HlQ==} engines: {node: '>= 0.4'} @@ -5106,21 +5591,22 @@ packages: resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==} engines: {iojs: '>=1.0.0', node: '>=0.10.0'} + rfdc@1.4.1: + resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==} + rimraf@3.0.2: resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==} deprecated: Rimraf versions prior to v4 are no longer supported hasBin: true - rimraf@6.0.1: - resolution: {integrity: sha512-9dkvaxAsk/xNXSJzMgFqqMCuFgt2+KsOFek3TMLfo8NCPfWpBmqwyNn5Y+NX56QUYfCtsyhF3ayiboEoUmJk/A==} - engines: {node: 20 || >=22} - hasBin: true - rollup@4.24.2: resolution: {integrity: sha512-do/DFGq5g6rdDhdpPq5qb2ecoczeK6y+2UAjdJ5trjQJj5f1AiVdLRWRc9A9/fFukfvJRgM0UXzxBIYMovm5ww==} engines: {node: '>=18.0.0', npm: '>=8.0.0'} hasBin: true + rrweb-cssom@0.7.1: + resolution: {integrity: sha512-TrEMa7JGdVm0UThDJSx7ddw5nVm3UJS9o9CCIZ72B1vSyEZoziDqBYP3XIoi/12lKrJR8rE3jeFHMok2F/Mnsg==} + run-applescript@7.0.0: resolution: {integrity: sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==} engines: {node: '>=18'} @@ -5168,6 +5654,9 @@ packages: resolution: {integrity: sha512-yEsN6TuxZhZ1Tl9iB81frTNS292m0I/IG7+w8lTvfcJQP2x3vnpOoevjBoE3Np5A6KnZM2+RtVenihj9t6NiYg==} engines: {node: '>=12'} + search-insights@2.17.2: + resolution: {integrity: sha512-zFNpOpUO+tY2D85KrxJ+aqwnIfdEGi06UH2+xEb+Bp9Mwznmauqc9djbnBibJO5mpfUPPa8st6Sx65+vbeO45g==} + semver@6.3.1: resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} hasBin: true @@ -5210,6 +5699,9 @@ packages: resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} engines: {node: '>=8'} + shiki@1.22.2: + resolution: {integrity: sha512-3IZau0NdGKXhH2bBlUk4w1IHNxPh6A5B2sUpyY+8utLu2j/h1QpFkAaUA1bAMxOWWGtTWcAh531vnS4NJKS/lA==} + side-channel@1.0.6: resolution: {integrity: sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==} engines: {node: '>= 0.4'} @@ -5267,6 +5759,9 @@ packages: resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==} engines: {node: '>= 8'} + space-separated-tokens@2.0.2: + resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==} + spawndamnit@2.0.0: resolution: {integrity: sha512-j4JKEcncSjFlqIwU5L/rp2N5SIPsdxaRsIv678+TZxZ0SRDJTm8JrxJMjE/XuiEZNEir3S8l0Fa3Ke339WI4qA==} @@ -5282,6 +5777,10 @@ packages: spdx-license-ids@3.0.12: resolution: {integrity: sha512-rr+VVSXtRhO4OHbXUiAF7xW3Bo9DuuF6C5jH+q/x15j2jniycgKbxU09Hr0WqlSLUs4i4ltHGXqTe7VHclYWyA==} + speakingurl@14.0.1: + resolution: {integrity: sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==} + engines: {node: '>=0.10.0'} + sprintf-js@1.0.3: resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} @@ -5299,12 +5798,6 @@ packages: resolution: {integrity: sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ==} engines: {node: '>=18'} - stocked@1.0.0-beta.33: - resolution: {integrity: sha512-ZXH3cnMrIsc0ULmgXIgJnkHhf7iimUDsYoAZqZXmWw2xwKbv0qhc/FMuuVMHG2G7Z3S7cG34fowDkJSNnzkBgg==} - engines: {node: '>=10'} - peerDependencies: - react: '>=16' - string-argv@0.3.2: resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==} engines: {node: '>=0.6.19'} @@ -5358,6 +5851,9 @@ packages: string_decoder@1.3.0: resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} + stringify-entities@4.0.4: + resolution: {integrity: sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==} + strip-ansi@3.0.1: resolution: {integrity: sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==} engines: {node: '>=0.10.0'} @@ -5410,6 +5906,10 @@ packages: engines: {node: '>=16 || 14 >=14.17'} hasBin: true + superjson@2.2.1: + resolution: {integrity: sha512-8iGv75BYOa0xRJHK5vRLEjE2H/i4lulTjzpUXic3Eg8akftYjkmQDa8JARQ42rlczXyFR3IeRoeFCc7RxHsYZA==} + engines: {node: '>=16'} + supports-color@2.0.0: resolution: {integrity: sha512-KKNVtd6pCYgPIKU4cp2733HWYCpplQhddZLBUryaAHou723x+FRzQ5Df824Fj+IyyuiQTRoub4SnIFfIcrp70g==} engines: {node: '>=0.8.0'} @@ -5462,6 +5962,9 @@ packages: engines: {node: '>=18.18.0'} hasBin: true + tabbable@6.2.0: + resolution: {integrity: sha512-Cat63mxsVJlzYvN51JmVXIgNoUokrIaT2zLclCXjRd8boZ0004U4KCs/sToJ75C6sdlByWxpYnb5Boif1VSFew==} + term-size@2.2.1: resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==} engines: {node: '>=8'} @@ -5491,8 +5994,8 @@ packages: resolution: {integrity: sha512-Kw36UHxJEELq2VUqdaSGR2/8cAsPgMtvX8uGVU6Jk26O66PhXec0A5ZnRYs47btbtwPDpXXF66+Fo3vimCM9aQ==} engines: {node: '>=16'} - tiny-case@1.0.3: - resolution: {integrity: sha512-Eet/eeMhkO6TX8mnUteS9zgPbUMQa4I6Kkp5ORiBD5476/m+PIRiumP5tmh5ioJpH7k51Kehawy2UDfsnxxY8Q==} + tiny-invariant@1.2.0: + resolution: {integrity: sha512-1Uhn/aqw5C6RI4KejVeTg6mIS7IqxnLJ8Mv2tV5rTc0qWobay7pDUz6Wi392Cnc8ak1H0F2cjoRzb2/AW4+Fvg==} tiny-invariant@1.3.3: resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==} @@ -5519,6 +6022,13 @@ packages: resolution: {integrity: sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==} engines: {node: '>=14.0.0'} + tldts-core@6.1.57: + resolution: {integrity: sha512-lXnRhuQpx3zU9EONF9F7HfcRLvN1uRYUBIiKL+C/gehC/77XTU+Jye6ui86GA3rU6FjlJ0triD1Tkjt2F/2lEg==} + + tldts@6.1.57: + resolution: {integrity: sha512-Oy7yDXK8meJl8vPMOldzA+MtueAJ5BrH4l4HXwZuj2AtfoQbLjmTJmjNWPUcAo+E/ibHn7QlqMS0BOcXJFJyHQ==} + hasBin: true + tmp@0.0.33: resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==} engines: {node: '>=0.6.0'} @@ -5537,6 +6047,10 @@ packages: resolution: {integrity: sha512-Loo5UUvLD9ScZ6jh8beX1T6sO1w2/MpCRpEP7V280GKMVUQ0Jzar2U3UJPsrdbziLEMMhu3Ujnq//rhiFuIeag==} engines: {node: '>=6'} + tough-cookie@5.0.0: + resolution: {integrity: sha512-FRKsF7cz96xIIeMZ82ehjC3xW2E+O2+v11udrDYewUbszngYhsGa8z6YUMMzO9QJZzzyd0nGGXnML/TReX6W8Q==} + engines: {node: '>=16'} + tr46@0.0.3: resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} @@ -5547,10 +6061,17 @@ packages: resolution: {integrity: sha512-l7FvfAHlcmulp8kr+flpQZmVwtu7nfRV7NZujtN0OqES8EL4O4e0qqzL0DC5gAvx/ZC/9lk6rhcUwYvkBnBnYA==} engines: {node: '>=12'} + tr46@5.0.0: + resolution: {integrity: sha512-tk2G5R2KRwBd+ZN0zaEXpmzdKyOYksXwywulIX95MBODjSzMIuQnQ3m8JxgbhnL1LeVo7lqQKsYa1O3Htl7K5g==} + engines: {node: '>=18'} + tree-kill@1.2.2: resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==} hasBin: true + trim-lines@3.0.1: + resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==} + ts-api-utils@1.3.0: resolution: {integrity: sha512-UQMIo7pb8WRomKR1/+MFVLTroIvDVtMX3K6OUir8ynLyzB8Jeriont2bTAtmNPa1ekAgN7YPDyf6V+ygrdU+eQ==} engines: {node: '>=16'} @@ -5560,6 +6081,27 @@ packages: ts-interface-checker@0.1.13: resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==} + ts-jest@29.0.3: + resolution: {integrity: sha512-Ibygvmuyq1qp/z3yTh9QTwVVAbFdDy/+4BtIQR2sp6baF2SJU/8CKK/hhnGIDY2L90Az2jIqTwZPnN2p+BweiQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + hasBin: true + peerDependencies: + '@babel/core': '>=7.0.0-beta.0 <8' + '@jest/types': ^29.0.0 + babel-jest: ^29.0.0 + esbuild: '*' + jest: ^29.0.0 + typescript: '>=4.3' + peerDependenciesMeta: + '@babel/core': + optional: true + '@jest/types': + optional: true + babel-jest: + optional: true + esbuild: + optional: true + ts-jest@29.2.5: resolution: {integrity: sha512-KD8zB2aAZrcKIdGk4OwpJggeLcH1FgrICqDSROWqlnJXGCXK4Mn6FcdK2B6670Xr73lHMG1kHw8R87A0ecZ+vA==} engines: {node: ^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0} @@ -5590,6 +6132,9 @@ packages: tslib@1.14.1: resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==} + tslib@2.3.1: + resolution: {integrity: sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw==} + tslib@2.8.0: resolution: {integrity: sha512-jWVzBLplnCmoaTr13V9dYbiQ99wvZRd0vNWaDRg+aVYRcjDF3nDksxFDE/+fkXnKhpnUUkmx5pK/v8mCtLVqZA==} @@ -5723,6 +6268,9 @@ packages: unbox-primitive@1.0.2: resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} + undici-types@5.26.5: + resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} + undici-types@6.19.8: resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==} @@ -5750,6 +6298,21 @@ packages: resolution: {integrity: sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==} engines: {node: '>=18'} + unist-util-is@6.0.0: + resolution: {integrity: sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==} + + unist-util-position@5.0.0: + resolution: {integrity: sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==} + + unist-util-stringify-position@4.0.0: + resolution: {integrity: sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==} + + unist-util-visit-parents@6.0.1: + resolution: {integrity: sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==} + + unist-util-visit@5.0.0: + resolution: {integrity: sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==} + universal-user-agent@6.0.1: resolution: {integrity: sha512-yCzhz6FN2wU1NiiQRogkTQszlQSlpWaw8SvVegAc+bDxbzHgh1vX8uIe8OYyMH6DwH+sdTJsgMl36+mSMdRJIQ==} @@ -5798,6 +6361,12 @@ packages: resolution: {integrity: sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + vfile-message@4.0.2: + resolution: {integrity: sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw==} + + vfile@6.0.3: + resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==} + vite-node@2.1.4: resolution: {integrity: sha512-kqa9v+oi4HwkG6g8ufRnb5AeplcRw8jUF6/7/Qz1qRQOXHImG8YnLbB+LLszENwFnoBl9xIf9nVdCFzNd7GQEg==} engines: {node: ^18.0.0 || >=20.0.0} @@ -5834,6 +6403,18 @@ packages: terser: optional: true + vitepress@1.4.1: + resolution: {integrity: sha512-C2rQ7PMlDVqgsaHOa0uJtgGGWaGv74QMaGL62lxKbtFkYtosJB5HAfZ8+pEbfzzvLemYaYwaiQdFLBlexK2sFw==} + hasBin: true + peerDependencies: + markdown-it-mathjax3: ^4 + postcss: ^8 + peerDependenciesMeta: + markdown-it-mathjax3: + optional: true + postcss: + optional: true + vitest@2.1.4: resolution: {integrity: sha512-eDjxbVAJw1UJJCHr5xr/xM86Zx+YxIEXGAR+bmnEID7z9qWfoxpHw0zdobz+TQAFOLT+nEXz3+gx6nUJ7RgmlQ==} engines: {node: ^18.0.0 || >=20.0.0} @@ -5859,10 +6440,33 @@ packages: jsdom: optional: true + vue-demi@0.14.10: + resolution: {integrity: sha512-nMZBOwuzabUO0nLgIcc6rycZEebF6eeUfaiQx9+WSk8e29IbLvPU9feI6tqW4kTo3hvoYAJkMh8n8D0fuISphg==} + engines: {node: '>=12'} + hasBin: true + peerDependencies: + '@vue/composition-api': ^1.0.0-rc.1 + vue: ^3.0.0-0 || ^2.6.0 + peerDependenciesMeta: + '@vue/composition-api': + optional: true + + vue@3.5.12: + resolution: {integrity: sha512-CLVZtXtn2ItBIi/zHZ0Sg1Xkb7+PU32bJJ8Bmy7ts3jxXTcbfsEfBivFYYWz1Hur+lalqGAh65Coin0r+HRUfg==} + peerDependencies: + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + w3c-xmlserializer@4.0.0: resolution: {integrity: sha512-d+BFHzbiCx6zGfz0HyQ6Rg69w9k19nviJspaj4yNscGjrHu94sVP+aRm75yEbCh+r2/yR+7q6hux9LVtbuTGBw==} engines: {node: '>=14'} + w3c-xmlserializer@5.0.0: + resolution: {integrity: sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==} + engines: {node: '>=18'} + walker@1.0.8: resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==} @@ -5887,14 +6491,26 @@ packages: resolution: {integrity: sha512-p41ogyeMUrw3jWclHWTQg1k05DSVXPLcVxRTYsXUk+ZooOCZLcoYgPZ/HL/D/N+uQPOtcp1me1WhBEaX02mhWg==} engines: {node: '>=12'} + whatwg-encoding@3.1.1: + resolution: {integrity: sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==} + engines: {node: '>=18'} + whatwg-mimetype@3.0.0: resolution: {integrity: sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q==} engines: {node: '>=12'} + whatwg-mimetype@4.0.0: + resolution: {integrity: sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==} + engines: {node: '>=18'} + whatwg-url@11.0.0: resolution: {integrity: sha512-RKT8HExMpoYx4igMiVMY83lN6UeITKJlBQ+vR/8ZJ8OCdSiN3RwCq+9gH0+Xzj0+5IrM6i4j/6LuvzbZIQgEcQ==} engines: {node: '>=12'} + whatwg-url@14.0.0: + resolution: {integrity: sha512-1lfMEm2IEr7RIV+f4lUNPOqfFL+pO+Xw3fJSqmjX9AbXcXcYOkCe1P6+9VBZB6n94af16NfZf+sSk0JCBZC9aw==} + engines: {node: '>=18'} + whatwg-url@5.0.0: resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} @@ -5994,6 +6610,10 @@ packages: resolution: {integrity: sha512-ICP2e+jsHvAj2E2lIHxa5tjXRlKDJo4IdvPvCXbXQGdzSfmSpNVyIKMvoZHjDY9DP0zV17iI85o90vRFXNccRw==} engines: {node: '>=12'} + xml-name-validator@5.0.0: + resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==} + engines: {node: '>=18'} + xmlchars@2.2.0: resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==} @@ -6014,6 +6634,10 @@ packages: yallist@4.0.0: resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==} + yaml@1.10.2: + resolution: {integrity: sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==} + engines: {node: '>= 6'} + yargs-parser@20.2.9: resolution: {integrity: sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==} engines: {node: '>=10'} @@ -6042,11 +6666,119 @@ packages: resolution: {integrity: sha512-Z2Fe1bn+eLstG8DRR6FTavGD+MeAwyfmouhHsIUgaADz8jvFKbO/fXc2trJKZg+5EBjh4gGm3iU/t3onKlXHIg==} engines: {node: '>=10'} - yup@1.4.0: - resolution: {integrity: sha512-wPbgkJRCqIf+OHyiTBQoJiP5PFuAXaWiJK6AmYkzQAh5/c2K9hzSApBZG5wV9KoKSePF7sAxmNSvh/13YHkFDg==} + yup@0.32.9: + resolution: {integrity: sha512-Ci1qN+i2H0XpY7syDQ0k5zKQ/DoxO0LzPg8PAR/X4Mpj6DqaeCoIYEEjDJwhArh3Fa7GWbQQVDZKeXYlSH4JMg==} + engines: {node: '>=10'} + + zwitch@2.0.4: + resolution: {integrity: sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==} snapshots: + '@algolia/autocomplete-core@1.9.3(@algolia/client-search@4.24.0)(algoliasearch@4.24.0)(search-insights@2.17.2)': + dependencies: + '@algolia/autocomplete-plugin-algolia-insights': 1.9.3(@algolia/client-search@4.24.0)(algoliasearch@4.24.0)(search-insights@2.17.2) + '@algolia/autocomplete-shared': 1.9.3(@algolia/client-search@4.24.0)(algoliasearch@4.24.0) + transitivePeerDependencies: + - '@algolia/client-search' + - algoliasearch + - search-insights + + '@algolia/autocomplete-plugin-algolia-insights@1.9.3(@algolia/client-search@4.24.0)(algoliasearch@4.24.0)(search-insights@2.17.2)': + dependencies: + '@algolia/autocomplete-shared': 1.9.3(@algolia/client-search@4.24.0)(algoliasearch@4.24.0) + search-insights: 2.17.2 + transitivePeerDependencies: + - '@algolia/client-search' + - algoliasearch + + '@algolia/autocomplete-preset-algolia@1.9.3(@algolia/client-search@4.24.0)(algoliasearch@4.24.0)': + dependencies: + '@algolia/autocomplete-shared': 1.9.3(@algolia/client-search@4.24.0)(algoliasearch@4.24.0) + '@algolia/client-search': 4.24.0 + algoliasearch: 4.24.0 + + '@algolia/autocomplete-shared@1.9.3(@algolia/client-search@4.24.0)(algoliasearch@4.24.0)': + dependencies: + '@algolia/client-search': 4.24.0 + algoliasearch: 4.24.0 + + '@algolia/cache-browser-local-storage@4.24.0': + dependencies: + '@algolia/cache-common': 4.24.0 + + '@algolia/cache-common@4.24.0': {} + + '@algolia/cache-in-memory@4.24.0': + dependencies: + '@algolia/cache-common': 4.24.0 + + '@algolia/client-account@4.24.0': + dependencies: + '@algolia/client-common': 4.24.0 + '@algolia/client-search': 4.24.0 + '@algolia/transporter': 4.24.0 + + '@algolia/client-analytics@4.24.0': + dependencies: + '@algolia/client-common': 4.24.0 + '@algolia/client-search': 4.24.0 + '@algolia/requester-common': 4.24.0 + '@algolia/transporter': 4.24.0 + + '@algolia/client-common@4.24.0': + dependencies: + '@algolia/requester-common': 4.24.0 + '@algolia/transporter': 4.24.0 + + '@algolia/client-personalization@4.24.0': + dependencies: + '@algolia/client-common': 4.24.0 + '@algolia/requester-common': 4.24.0 + '@algolia/transporter': 4.24.0 + + '@algolia/client-search@4.24.0': + dependencies: + '@algolia/client-common': 4.24.0 + '@algolia/requester-common': 4.24.0 + '@algolia/transporter': 4.24.0 + + '@algolia/logger-common@4.24.0': {} + + '@algolia/logger-console@4.24.0': + dependencies: + '@algolia/logger-common': 4.24.0 + + '@algolia/recommend@4.24.0': + dependencies: + '@algolia/cache-browser-local-storage': 4.24.0 + '@algolia/cache-common': 4.24.0 + '@algolia/cache-in-memory': 4.24.0 + '@algolia/client-common': 4.24.0 + '@algolia/client-search': 4.24.0 + '@algolia/logger-common': 4.24.0 + '@algolia/logger-console': 4.24.0 + '@algolia/requester-browser-xhr': 4.24.0 + '@algolia/requester-common': 4.24.0 + '@algolia/requester-node-http': 4.24.0 + '@algolia/transporter': 4.24.0 + + '@algolia/requester-browser-xhr@4.24.0': + dependencies: + '@algolia/requester-common': 4.24.0 + + '@algolia/requester-common@4.24.0': {} + + '@algolia/requester-node-http@4.24.0': + dependencies: + '@algolia/requester-common': 4.24.0 + + '@algolia/transporter@4.24.0': + dependencies: + '@algolia/cache-common': 4.24.0 + '@algolia/logger-common': 4.24.0 + '@algolia/requester-common': 4.24.0 + '@ampproject/remapping@2.3.0': dependencies: '@jridgewell/gen-mapping': 0.3.5 @@ -6082,6 +6814,26 @@ snapshots: '@babel/compat-data@7.26.0': {} + '@babel/core@7.19.6': + dependencies: + '@ampproject/remapping': 2.3.0 + '@babel/code-frame': 7.26.0 + '@babel/generator': 7.26.0 + '@babel/helper-compilation-targets': 7.25.9 + '@babel/helper-module-transforms': 7.26.0(@babel/core@7.19.6) + '@babel/helpers': 7.26.0 + '@babel/parser': 7.26.1 + '@babel/template': 7.25.9 + '@babel/traverse': 7.25.9 + '@babel/types': 7.26.0 + convert-source-map: 1.9.0 + debug: 4.3.7 + gensync: 1.0.0-beta.2 + json5: 2.2.3 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + '@babel/core@7.26.0': dependencies: '@ampproject/remapping': 2.3.0 @@ -6129,6 +6881,19 @@ snapshots: lru-cache: 5.1.1 semver: 6.3.1 + '@babel/helper-create-class-features-plugin@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-annotate-as-pure': 7.25.9 + '@babel/helper-member-expression-to-functions': 7.25.9 + '@babel/helper-optimise-call-expression': 7.25.9 + '@babel/helper-replace-supers': 7.25.9(@babel/core@7.19.6) + '@babel/helper-skip-transparent-expression-wrappers': 7.25.9 + '@babel/traverse': 7.25.9 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + '@babel/helper-create-class-features-plugin@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6142,6 +6907,13 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/helper-create-regexp-features-plugin@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-annotate-as-pure': 7.25.9 + regexpu-core: 6.1.1 + semver: 6.3.1 + '@babel/helper-create-regexp-features-plugin@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6149,6 +6921,17 @@ snapshots: regexpu-core: 6.1.1 semver: 6.3.1 + '@babel/helper-define-polyfill-provider@0.6.2(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-compilation-targets': 7.25.9 + '@babel/helper-plugin-utils': 7.25.9 + debug: 4.3.7 + lodash.debounce: 4.0.8 + resolve: 1.22.8 + transitivePeerDependencies: + - supports-color + '@babel/helper-define-polyfill-provider@0.6.2(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6174,6 +6957,15 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/helper-module-transforms@7.26.0(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-module-imports': 7.25.9 + '@babel/helper-validator-identifier': 7.25.9 + '@babel/traverse': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/helper-module-transforms@7.26.0(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6189,6 +6981,15 @@ snapshots: '@babel/helper-plugin-utils@7.25.9': {} + '@babel/helper-remap-async-to-generator@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-annotate-as-pure': 7.25.9 + '@babel/helper-wrap-function': 7.25.9 + '@babel/traverse': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/helper-remap-async-to-generator@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6198,6 +6999,15 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/helper-replace-supers@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-member-expression-to-functions': 7.25.9 + '@babel/helper-optimise-call-expression': 7.25.9 + '@babel/traverse': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/helper-replace-supers@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6244,6 +7054,14 @@ snapshots: dependencies: '@babel/types': 7.26.0 + '@babel/plugin-bugfix-firefox-class-in-computed-class-key@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/traverse': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-bugfix-firefox-class-in-computed-class-key@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6252,16 +7070,35 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-bugfix-safari-class-field-initializer-scope@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-bugfix-safari-class-field-initializer-scope@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-skip-transparent-expression-wrappers': 7.25.9 + '@babel/plugin-transform-optional-chaining': 7.25.9(@babel/core@7.19.6) + transitivePeerDependencies: + - supports-color + '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6271,6 +7108,14 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/traverse': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6279,112 +7124,235 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 + '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + optional: true + + '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + optional: true + + '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + optional: true + + '@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 '@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + optional: true + + '@babel/plugin-syntax-import-assertions@7.26.0(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 '@babel/plugin-syntax-import-assertions@7.26.0(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-syntax-import-attributes@7.26.0(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-syntax-import-attributes@7.26.0(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + optional: true + + '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + optional: true + + '@babel/plugin-syntax-jsx@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 '@babel/plugin-syntax-jsx@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 - '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.26.0)': + '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.19.6)': dependencies: - '@babel/core': 7.26.0 + '@babel/core': 7.19.6 '@babel/helper-plugin-utils': 7.25.9 - '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.26.0)': + '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + optional: true - '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.26.0)': + '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.19.6)': dependencies: - '@babel/core': 7.26.0 + '@babel/core': 7.19.6 '@babel/helper-plugin-utils': 7.25.9 - '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.26.0)': + '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + optional: true - '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.26.0)': + '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.19.6)': dependencies: - '@babel/core': 7.26.0 + '@babel/core': 7.19.6 '@babel/helper-plugin-utils': 7.25.9 - '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.26.0)': + '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + optional: true - '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.26.0)': + '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.19.6)': dependencies: - '@babel/core': 7.26.0 + '@babel/core': 7.19.6 '@babel/helper-plugin-utils': 7.25.9 - '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.26.0)': + '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + optional: true - '@babel/plugin-syntax-typescript@7.25.9(@babel/core@7.26.0)': + '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.19.6)': dependencies: - '@babel/core': 7.26.0 + '@babel/core': 7.19.6 '@babel/helper-plugin-utils': 7.25.9 - '@babel/plugin-syntax-unicode-sets-regex@7.18.6(@babel/core@7.26.0)': + '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 - '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.26.0) '@babel/helper-plugin-utils': 7.25.9 + optional: true - '@babel/plugin-transform-arrow-functions@7.25.9(@babel/core@7.26.0)': + '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.19.6)': dependencies: - '@babel/core': 7.26.0 + '@babel/core': 7.19.6 '@babel/helper-plugin-utils': 7.25.9 - '@babel/plugin-transform-async-generator-functions@7.25.9(@babel/core@7.26.0)': + '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.26.0)': + dependencies: + '@babel/core': 7.26.0 + '@babel/helper-plugin-utils': 7.25.9 + optional: true + + '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + + '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.26.0)': + dependencies: + '@babel/core': 7.26.0 + '@babel/helper-plugin-utils': 7.25.9 + optional: true + + '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + + '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.26.0)': + dependencies: + '@babel/core': 7.26.0 + '@babel/helper-plugin-utils': 7.25.9 + optional: true + + '@babel/plugin-syntax-typescript@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + + '@babel/plugin-syntax-unicode-sets-regex@7.18.6(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + + '@babel/plugin-syntax-unicode-sets-regex@7.18.6(@babel/core@7.26.0)': + dependencies: + '@babel/core': 7.26.0 + '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.26.0) + '@babel/helper-plugin-utils': 7.25.9 + + '@babel/plugin-transform-arrow-functions@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + + '@babel/plugin-transform-arrow-functions@7.25.9(@babel/core@7.26.0)': + dependencies: + '@babel/core': 7.26.0 + '@babel/helper-plugin-utils': 7.25.9 + + '@babel/plugin-transform-async-generator-functions@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-remap-async-to-generator': 7.25.9(@babel/core@7.19.6) + '@babel/traverse': 7.25.9 + transitivePeerDependencies: + - supports-color + + '@babel/plugin-transform-async-generator-functions@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 @@ -6393,6 +7361,15 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-async-to-generator@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-module-imports': 7.25.9 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-remap-async-to-generator': 7.25.9(@babel/core@7.19.6) + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-async-to-generator@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6402,16 +7379,34 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-block-scoped-functions@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-block-scoped-functions@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-block-scoping@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-block-scoping@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-class-properties@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-class-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-class-properties@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6420,6 +7415,14 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-class-static-block@7.26.0(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-class-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-class-static-block@7.26.0(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6428,6 +7431,18 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-classes@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-annotate-as-pure': 7.25.9 + '@babel/helper-compilation-targets': 7.25.9 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-replace-supers': 7.25.9(@babel/core@7.19.6) + '@babel/traverse': 7.25.9 + globals: 11.12.0 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-classes@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6440,39 +7455,80 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-computed-properties@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/template': 7.25.9 + '@babel/plugin-transform-computed-properties@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 '@babel/template': 7.25.9 + '@babel/plugin-transform-destructuring@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-destructuring@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-dotall-regex@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-dotall-regex@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.26.0) '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-duplicate-keys@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-duplicate-keys@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-duplicate-named-capturing-groups-regex@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-duplicate-named-capturing-groups-regex@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.26.0) '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-dynamic-import@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-dynamic-import@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-exponentiation-operator@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-builder-binary-assignment-operator-visitor': 7.25.9 + '@babel/helper-plugin-utils': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-exponentiation-operator@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6481,11 +7537,24 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-export-namespace-from@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-export-namespace-from@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-for-of@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-skip-transparent-expression-wrappers': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-for-of@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6494,6 +7563,15 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-function-name@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-compilation-targets': 7.25.9 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/traverse': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-function-name@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6503,26 +7581,54 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-json-strings@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-json-strings@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-literals@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-literals@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-logical-assignment-operators@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-logical-assignment-operators@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-member-expression-literals@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-member-expression-literals@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-modules-amd@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-module-transforms': 7.26.0(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-modules-amd@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6531,6 +7637,15 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-modules-commonjs@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-module-transforms': 7.26.0(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-simple-access': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-modules-commonjs@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6540,6 +7655,16 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-modules-systemjs@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-module-transforms': 7.26.0(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-validator-identifier': 7.25.9 + '@babel/traverse': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-modules-systemjs@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6550,6 +7675,14 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-modules-umd@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-module-transforms': 7.26.0(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-modules-umd@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6558,27 +7691,55 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-named-capturing-groups-regex@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-named-capturing-groups-regex@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.26.0) '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-new-target@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-new-target@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-nullish-coalescing-operator@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-nullish-coalescing-operator@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-numeric-separator@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-numeric-separator@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-object-rest-spread@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-compilation-targets': 7.25.9 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-parameters': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-object-rest-spread@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6586,6 +7747,14 @@ snapshots: '@babel/helper-plugin-utils': 7.25.9 '@babel/plugin-transform-parameters': 7.25.9(@babel/core@7.26.0) + '@babel/plugin-transform-object-super@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-replace-supers': 7.25.9(@babel/core@7.19.6) + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-object-super@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6594,11 +7763,24 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-optional-catch-binding@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-optional-catch-binding@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-optional-chaining@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-skip-transparent-expression-wrappers': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-optional-chaining@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6607,11 +7789,24 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-parameters@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-parameters@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-private-methods@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-class-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-private-methods@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6620,6 +7815,15 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-private-property-in-object@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-annotate-as-pure': 7.25.9 + '@babel/helper-create-class-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-private-property-in-object@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6629,16 +7833,33 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-property-literals@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-property-literals@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-react-display-name@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-react-display-name@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-react-jsx-development@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/plugin-transform-react-jsx': 7.25.9(@babel/core@7.19.6) + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-react-jsx-development@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6646,6 +7867,17 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-react-jsx@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-annotate-as-pure': 7.25.9 + '@babel/helper-module-imports': 7.25.9 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-syntax-jsx': 7.25.9(@babel/core@7.19.6) + '@babel/types': 7.26.0 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-react-jsx@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6657,34 +7889,70 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-react-pure-annotations@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-annotate-as-pure': 7.25.9 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-react-pure-annotations@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-annotate-as-pure': 7.25.9 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-regenerator@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + regenerator-transform: 0.15.2 + '@babel/plugin-transform-regenerator@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 regenerator-transform: 0.15.2 + '@babel/plugin-transform-regexp-modifiers@7.26.0(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-regexp-modifiers@7.26.0(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.26.0) '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-reserved-words@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-reserved-words@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-shorthand-properties@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-shorthand-properties@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-spread@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-skip-transparent-expression-wrappers': 7.25.9 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-spread@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6693,44 +7961,157 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-sticky-regex@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-sticky-regex@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-template-literals@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-template-literals@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-typeof-symbol@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-typeof-symbol@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-unicode-escapes@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-unicode-escapes@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-unicode-property-regex@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-unicode-property-regex@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.26.0) '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-unicode-regex@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-unicode-regex@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.26.0) '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-unicode-sets-regex@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.19.6) + '@babel/helper-plugin-utils': 7.25.9 + '@babel/plugin-transform-unicode-sets-regex@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 '@babel/helper-create-regexp-features-plugin': 7.25.9(@babel/core@7.26.0) '@babel/helper-plugin-utils': 7.25.9 + '@babel/preset-env@7.26.0(@babel/core@7.19.6)': + dependencies: + '@babel/compat-data': 7.26.0 + '@babel/core': 7.19.6 + '@babel/helper-compilation-targets': 7.25.9 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-validator-option': 7.25.9 + '@babel/plugin-bugfix-firefox-class-in-computed-class-key': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-bugfix-safari-class-field-initializer-scope': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-proposal-private-property-in-object': 7.21.0-placeholder-for-preset-env.2(@babel/core@7.19.6) + '@babel/plugin-syntax-import-assertions': 7.26.0(@babel/core@7.19.6) + '@babel/plugin-syntax-import-attributes': 7.26.0(@babel/core@7.19.6) + '@babel/plugin-syntax-unicode-sets-regex': 7.18.6(@babel/core@7.19.6) + '@babel/plugin-transform-arrow-functions': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-async-generator-functions': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-async-to-generator': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-block-scoped-functions': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-block-scoping': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-class-properties': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-class-static-block': 7.26.0(@babel/core@7.19.6) + '@babel/plugin-transform-classes': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-computed-properties': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-destructuring': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-dotall-regex': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-duplicate-keys': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-duplicate-named-capturing-groups-regex': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-dynamic-import': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-exponentiation-operator': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-export-namespace-from': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-for-of': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-function-name': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-json-strings': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-literals': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-logical-assignment-operators': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-member-expression-literals': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-modules-amd': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-modules-commonjs': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-modules-systemjs': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-modules-umd': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-named-capturing-groups-regex': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-new-target': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-nullish-coalescing-operator': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-numeric-separator': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-object-rest-spread': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-object-super': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-optional-catch-binding': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-optional-chaining': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-parameters': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-private-methods': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-private-property-in-object': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-property-literals': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-regenerator': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-regexp-modifiers': 7.26.0(@babel/core@7.19.6) + '@babel/plugin-transform-reserved-words': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-shorthand-properties': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-spread': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-sticky-regex': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-template-literals': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-typeof-symbol': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-unicode-escapes': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-unicode-property-regex': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-unicode-regex': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-unicode-sets-regex': 7.25.9(@babel/core@7.19.6) + '@babel/preset-modules': 0.1.6-no-external-plugins(@babel/core@7.19.6) + babel-plugin-polyfill-corejs2: 0.4.11(@babel/core@7.19.6) + babel-plugin-polyfill-corejs3: 0.10.6(@babel/core@7.19.6) + babel-plugin-polyfill-regenerator: 0.6.2(@babel/core@7.19.6) + core-js-compat: 3.38.1 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + '@babel/preset-env@7.26.0(@babel/core@7.26.0)': dependencies: '@babel/compat-data': 7.26.0 @@ -6806,6 +8187,13 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/preset-modules@0.1.6-no-external-plugins(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/types': 7.26.0 + esutils: 2.0.3 + '@babel/preset-modules@0.1.6-no-external-plugins(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6813,6 +8201,18 @@ snapshots: '@babel/types': 7.26.0 esutils: 2.0.3 + '@babel/preset-react@7.25.9(@babel/core@7.19.6)': + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-plugin-utils': 7.25.9 + '@babel/helper-validator-option': 7.25.9 + '@babel/plugin-transform-react-display-name': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-react-jsx': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-react-jsx-development': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-transform-react-pure-annotations': 7.25.9(@babel/core@7.19.6) + transitivePeerDependencies: + - supports-color + '@babel/preset-react@7.25.9(@babel/core@7.26.0)': dependencies: '@babel/core': 7.26.0 @@ -6999,6 +8399,33 @@ snapshots: '@colors/colors@1.5.0': optional: true + '@docsearch/css@3.6.2': {} + + '@docsearch/js@3.6.2(@algolia/client-search@4.24.0)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(search-insights@2.17.2)': + dependencies: + '@docsearch/react': 3.6.2(@algolia/client-search@4.24.0)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(search-insights@2.17.2) + preact: 10.24.3 + transitivePeerDependencies: + - '@algolia/client-search' + - '@types/react' + - react + - react-dom + - search-insights + + '@docsearch/react@3.6.2(@algolia/client-search@4.24.0)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(search-insights@2.17.2)': + dependencies: + '@algolia/autocomplete-core': 1.9.3(@algolia/client-search@4.24.0)(algoliasearch@4.24.0)(search-insights@2.17.2) + '@algolia/autocomplete-preset-algolia': 1.9.3(@algolia/client-search@4.24.0)(algoliasearch@4.24.0) + '@docsearch/css': 3.6.2 + algoliasearch: 4.24.0 + optionalDependencies: + '@types/react': 18.3.12 + react: 18.3.1 + react-dom: 18.3.1(react@18.3.1) + search-insights: 2.17.2 + transitivePeerDependencies: + - '@algolia/client-search' + '@effect/schema@0.71.1(effect@3.6.5)': dependencies: effect: 3.6.5 @@ -7286,7 +8713,7 @@ snapshots: '@jest/console@29.7.0': dependencies: '@jest/types': 29.6.3 - '@types/node': 22.8.1 + '@types/node': 18.19.60 chalk: 4.1.2 jest-message-util: 29.7.0 jest-util: 29.7.0 @@ -7299,14 +8726,49 @@ snapshots: '@jest/test-result': 29.7.0 '@jest/transform': 29.7.0 '@jest/types': 29.6.3 - '@types/node': 22.8.1 + '@types/node': 18.19.60 + ansi-escapes: 4.3.2 + chalk: 4.1.2 + ci-info: 3.9.0 + exit: 0.1.2 + graceful-fs: 4.2.11 + jest-changed-files: 29.7.0 + jest-config: 29.7.0(@types/node@18.19.60) + jest-haste-map: 29.7.0 + jest-message-util: 29.7.0 + jest-regex-util: 29.6.3 + jest-resolve: 29.7.0 + jest-resolve-dependencies: 29.7.0 + jest-runner: 29.7.0 + jest-runtime: 29.7.0 + jest-snapshot: 29.7.0 + jest-util: 29.7.0 + jest-validate: 29.7.0 + jest-watcher: 29.7.0 + micromatch: 4.0.8 + pretty-format: 29.7.0 + slash: 3.0.0 + strip-ansi: 6.0.1 + transitivePeerDependencies: + - babel-plugin-macros + - supports-color + - ts-node + + '@jest/core@29.7.0(babel-plugin-macros@3.1.0)': + dependencies: + '@jest/console': 29.7.0 + '@jest/reporters': 29.7.0 + '@jest/test-result': 29.7.0 + '@jest/transform': 29.7.0 + '@jest/types': 29.6.3 + '@types/node': 18.19.60 ansi-escapes: 4.3.2 chalk: 4.1.2 ci-info: 3.9.0 exit: 0.1.2 graceful-fs: 4.2.11 jest-changed-files: 29.7.0 - jest-config: 29.7.0(@types/node@22.8.1) + jest-config: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) jest-haste-map: 29.7.0 jest-message-util: 29.7.0 jest-regex-util: 29.6.3 @@ -7331,7 +8793,7 @@ snapshots: dependencies: '@jest/fake-timers': 29.7.0 '@jest/types': 29.6.3 - '@types/node': 22.8.1 + '@types/node': 22.8.2 jest-mock: 29.7.0 '@jest/expect-utils@29.7.0': @@ -7349,7 +8811,7 @@ snapshots: dependencies: '@jest/types': 29.6.3 '@sinonjs/fake-timers': 10.3.0 - '@types/node': 22.8.1 + '@types/node': 22.8.2 jest-message-util: 29.7.0 jest-mock: 29.7.0 jest-util: 29.7.0 @@ -7371,7 +8833,7 @@ snapshots: '@jest/transform': 29.7.0 '@jest/types': 29.6.3 '@jridgewell/trace-mapping': 0.3.25 - '@types/node': 22.8.1 + '@types/node': 18.19.60 chalk: 4.1.2 collect-v8-coverage: 1.0.2 exit: 0.1.2 @@ -7418,7 +8880,7 @@ snapshots: '@jest/transform@29.7.0': dependencies: - '@babel/core': 7.26.0 + '@babel/core': 7.19.6 '@jest/types': 29.6.3 '@jridgewell/trace-mapping': 0.3.25 babel-plugin-istanbul: 6.1.1 @@ -7436,27 +8898,33 @@ snapshots: transitivePeerDependencies: - supports-color + '@jest/types@26.6.2': + dependencies: + '@types/istanbul-lib-coverage': 2.0.6 + '@types/istanbul-reports': 3.0.4 + '@types/node': 18.19.60 + '@types/yargs': 15.0.19 + chalk: 4.1.2 + '@jest/types@29.6.3': dependencies: '@jest/schemas': 29.6.3 '@types/istanbul-lib-coverage': 2.0.6 '@types/istanbul-reports': 3.0.4 - '@types/node': 22.8.1 + '@types/node': 18.19.60 '@types/yargs': 17.0.33 chalk: 4.1.2 '@jridgewell/gen-mapping@0.3.5': dependencies: '@jridgewell/set-array': 1.2.1 - '@jridgewell/sourcemap-codec': 1.4.15 + '@jridgewell/sourcemap-codec': 1.5.0 '@jridgewell/trace-mapping': 0.3.25 '@jridgewell/resolve-uri@3.1.2': {} '@jridgewell/set-array@1.2.1': {} - '@jridgewell/sourcemap-codec@1.4.15': {} - '@jridgewell/sourcemap-codec@1.5.0': {} '@jridgewell/trace-mapping@0.3.25': @@ -7480,23 +8948,23 @@ snapshots: globby: 11.1.0 read-yaml-file: 1.1.0 - '@microsoft/api-extractor-model@7.29.8(@types/node@22.8.1)': + '@microsoft/api-extractor-model@7.29.8(@types/node@20.17.2)': dependencies: '@microsoft/tsdoc': 0.15.0 '@microsoft/tsdoc-config': 0.17.0 - '@rushstack/node-core-library': 5.9.0(@types/node@22.8.1) + '@rushstack/node-core-library': 5.9.0(@types/node@20.17.2) transitivePeerDependencies: - '@types/node' - '@microsoft/api-extractor@7.47.11(@types/node@22.8.1)': + '@microsoft/api-extractor@7.47.11(@types/node@20.17.2)': dependencies: - '@microsoft/api-extractor-model': 7.29.8(@types/node@22.8.1) + '@microsoft/api-extractor-model': 7.29.8(@types/node@20.17.2) '@microsoft/tsdoc': 0.15.0 '@microsoft/tsdoc-config': 0.17.0 - '@rushstack/node-core-library': 5.9.0(@types/node@22.8.1) + '@rushstack/node-core-library': 5.9.0(@types/node@20.17.2) '@rushstack/rig-package': 0.5.3 - '@rushstack/terminal': 0.14.2(@types/node@22.8.1) - '@rushstack/ts-command-line': 4.23.0(@types/node@22.8.1) + '@rushstack/terminal': 0.14.2(@types/node@20.17.2) + '@rushstack/ts-command-line': 4.23.0(@types/node@20.17.2) lodash: 4.17.21 minimatch: 3.0.8 resolve: 1.22.1 @@ -7715,7 +9183,7 @@ snapshots: '@rollup/rollup-win32-x64-msvc@4.24.2': optional: true - '@rushstack/node-core-library@5.9.0(@types/node@22.8.1)': + '@rushstack/node-core-library@5.9.0(@types/node@20.17.2)': dependencies: ajv: 8.13.0 ajv-draft-04: 1.0.0(ajv@8.13.0) @@ -7726,23 +9194,23 @@ snapshots: resolve: 1.22.1 semver: 7.5.4 optionalDependencies: - '@types/node': 22.8.1 + '@types/node': 20.17.2 '@rushstack/rig-package@0.5.3': dependencies: resolve: 1.22.1 strip-json-comments: 3.1.1 - '@rushstack/terminal@0.14.2(@types/node@22.8.1)': + '@rushstack/terminal@0.14.2(@types/node@20.17.2)': dependencies: - '@rushstack/node-core-library': 5.9.0(@types/node@22.8.1) + '@rushstack/node-core-library': 5.9.0(@types/node@20.17.2) supports-color: 8.1.1 optionalDependencies: - '@types/node': 22.8.1 + '@types/node': 20.17.2 - '@rushstack/ts-command-line@4.23.0(@types/node@22.8.1)': + '@rushstack/ts-command-line@4.23.0(@types/node@20.17.2)': dependencies: - '@rushstack/terminal': 0.14.2(@types/node@22.8.1) + '@rushstack/terminal': 0.14.2(@types/node@20.17.2) '@types/argparse': 1.0.38 argparse: 1.0.10 string-argv: 0.3.2 @@ -7757,6 +9225,37 @@ snapshots: transitivePeerDependencies: - zenObservable + '@shikijs/core@1.22.2': + dependencies: + '@shikijs/engine-javascript': 1.22.2 + '@shikijs/engine-oniguruma': 1.22.2 + '@shikijs/types': 1.22.2 + '@shikijs/vscode-textmate': 9.3.0 + '@types/hast': 3.0.4 + hast-util-to-html: 9.0.3 + + '@shikijs/engine-javascript@1.22.2': + dependencies: + '@shikijs/types': 1.22.2 + '@shikijs/vscode-textmate': 9.3.0 + oniguruma-to-js: 0.4.3 + + '@shikijs/engine-oniguruma@1.22.2': + dependencies: + '@shikijs/types': 1.22.2 + '@shikijs/vscode-textmate': 9.3.0 + + '@shikijs/transformers@1.22.2': + dependencies: + shiki: 1.22.2 + + '@shikijs/types@1.22.2': + dependencies: + '@shikijs/vscode-textmate': 9.3.0 + '@types/hast': 3.0.4 + + '@shikijs/vscode-textmate@9.3.0': {} + '@sinclair/typebox@0.27.8': {} '@sindresorhus/is@4.6.0': {} @@ -7787,6 +9286,17 @@ snapshots: '@size-limit/file': 11.1.6(size-limit@11.1.6) size-limit: 11.1.6 + '@testing-library/dom@10.4.0': + dependencies: + '@babel/code-frame': 7.26.0 + '@babel/runtime': 7.26.0 + '@types/aria-query': 5.0.4 + aria-query: 5.3.0 + chalk: 4.1.2 + dom-accessibility-api: 0.5.16 + lz-string: 1.5.0 + pretty-format: 27.5.1 + '@testing-library/dom@8.19.0': dependencies: '@babel/code-frame': 7.26.0 @@ -7798,10 +9308,18 @@ snapshots: lz-string: 1.5.0 pretty-format: 27.5.1 - '@testing-library/react@16.0.1(@testing-library/dom@8.19.0)(@types/react-dom@18.3.1)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)': + '@testing-library/react@13.4.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)': dependencies: '@babel/runtime': 7.26.0 '@testing-library/dom': 8.19.0 + '@types/react-dom': 18.3.1 + react: 18.2.0 + react-dom: 18.2.0(react@18.2.0) + + '@testing-library/react@16.0.1(@testing-library/dom@10.4.0)(@types/react-dom@18.3.1)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)': + dependencies: + '@babel/runtime': 7.26.0 + '@testing-library/dom': 10.4.0 react: 18.3.1 react-dom: 18.3.1(react@18.3.1) optionalDependencies: @@ -7814,6 +9332,8 @@ snapshots: '@types/aria-query@4.2.2': {} + '@types/aria-query@5.0.4': {} + '@types/babel__core@7.20.5': dependencies: '@babel/parser': 7.26.1 @@ -7839,7 +9359,11 @@ snapshots: '@types/graceful-fs@4.1.9': dependencies: - '@types/node': 22.8.1 + '@types/node': 18.19.60 + + '@types/hast@3.0.4': + dependencies: + '@types/unist': 3.0.3 '@types/istanbul-lib-coverage@2.0.6': {} @@ -7851,35 +9375,71 @@ snapshots: dependencies: '@types/istanbul-lib-report': 3.0.3 - '@types/jest@29.5.14': + '@types/jest@26.0.24': dependencies: - expect: 29.7.0 - pretty-format: 29.7.0 + jest-diff: 26.6.2 + pretty-format: 26.6.2 '@types/jsdom@20.0.1': dependencies: - '@types/node': 22.8.1 + '@types/node': 22.8.2 '@types/tough-cookie': 4.0.5 parse5: 7.2.1 '@types/json-schema@7.0.15': {} + '@types/linkify-it@5.0.0': {} + + '@types/lodash@4.14.161': {} + '@types/lodash@4.17.12': {} + '@types/markdown-it@14.1.2': + dependencies: + '@types/linkify-it': 5.0.0 + '@types/mdurl': 2.0.0 + + '@types/mdast@4.0.4': + dependencies: + '@types/unist': 3.0.3 + + '@types/mdurl@2.0.0': {} + '@types/node@12.20.55': {} - '@types/node@22.8.1': + '@types/node@18.19.60': + dependencies: + undici-types: 5.26.5 + + '@types/node@20.17.2': + dependencies: + undici-types: 6.19.8 + + '@types/node@22.8.2': dependencies: undici-types: 6.19.8 '@types/normalize-package-data@2.4.4': {} + '@types/parse-json@4.0.2': + optional: true + '@types/prop-types@15.7.13': {} + '@types/react-dom@18.0.6': + dependencies: + '@types/react': 18.3.12 + '@types/react-dom@18.3.1': dependencies: '@types/react': 18.3.12 + '@types/react@18.0.23': + dependencies: + '@types/prop-types': 15.7.13 + '@types/scheduler': 0.23.0 + csstype: 3.1.3 + '@types/react@18.3.12': dependencies: '@types/prop-types': 15.7.13 @@ -7887,22 +9447,32 @@ snapshots: '@types/resolve@1.20.6': {} + '@types/scheduler@0.23.0': {} + '@types/semver@7.5.8': {} '@types/stack-utils@2.0.3': {} '@types/tough-cookie@4.0.5': {} + '@types/unist@3.0.3': {} + + '@types/web-bluetooth@0.0.20': {} + '@types/yargs-parser@21.0.3': {} + '@types/yargs@15.0.19': + dependencies: + '@types/yargs-parser': 21.0.3 + '@types/yargs@17.0.33': dependencies: '@types/yargs-parser': 21.0.3 - '@typescript-eslint/eslint-plugin@5.62.0(@typescript-eslint/parser@5.62.0(eslint@8.57.1)(typescript@4.8.4))(eslint@8.57.1)(typescript@4.8.4)': + '@typescript-eslint/eslint-plugin@5.62.0(@typescript-eslint/parser@5.62.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@4.8.4)': dependencies: '@eslint-community/regexpp': 4.12.1 - '@typescript-eslint/parser': 5.62.0(eslint@9.13.0(jiti@2.3.3))(typescript@5.6.3) + '@typescript-eslint/parser': 5.62.0(eslint@8.57.1)(typescript@4.8.4) '@typescript-eslint/scope-manager': 5.62.0 '@typescript-eslint/type-utils': 5.62.0(eslint@8.57.1)(typescript@4.8.4) '@typescript-eslint/utils': 5.62.0(eslint@8.57.1)(typescript@4.8.4) @@ -7948,18 +9518,6 @@ snapshots: transitivePeerDependencies: - supports-color - '@typescript-eslint/parser@5.62.0(eslint@9.13.0(jiti@2.3.3))(typescript@5.6.3)': - dependencies: - '@typescript-eslint/scope-manager': 5.62.0 - '@typescript-eslint/types': 5.62.0 - '@typescript-eslint/typescript-estree': 5.62.0(typescript@4.8.4) - debug: 4.3.7 - eslint: 9.13.0(jiti@2.3.3) - optionalDependencies: - typescript: 5.6.3 - transitivePeerDependencies: - - supports-color - '@typescript-eslint/parser@8.11.0(eslint@9.13.0(jiti@2.3.3))(typescript@5.6.3)': dependencies: '@typescript-eslint/scope-manager': 8.11.0 @@ -8078,6 +9636,11 @@ snapshots: '@ungap/structured-clone@1.2.0': {} + '@vitejs/plugin-vue@5.1.4(vite@5.4.10(@types/node@22.8.2))(vue@3.5.12(typescript@5.6.3))': + dependencies: + vite: 5.4.10(@types/node@22.8.2) + vue: 3.5.12(typescript@5.6.3) + '@vitest/expect@2.1.4': dependencies: '@vitest/spy': 2.1.4 @@ -8085,13 +9648,21 @@ snapshots: chai: 5.1.2 tinyrainbow: 1.2.0 - '@vitest/mocker@2.1.4(vite@5.4.10(@types/node@22.8.1))': + '@vitest/mocker@2.1.4(vite@5.4.10(@types/node@20.17.2))': + dependencies: + '@vitest/spy': 2.1.4 + estree-walker: 3.0.3 + magic-string: 0.30.12 + optionalDependencies: + vite: 5.4.10(@types/node@20.17.2) + + '@vitest/mocker@2.1.4(vite@5.4.10(@types/node@22.8.2))': dependencies: '@vitest/spy': 2.1.4 estree-walker: 3.0.3 magic-string: 0.30.12 optionalDependencies: - vite: 5.4.10(@types/node@22.8.1) + vite: 5.4.10(@types/node@22.8.2) '@vitest/pretty-format@2.1.4': dependencies: @@ -8118,6 +9689,108 @@ snapshots: loupe: 3.1.2 tinyrainbow: 1.2.0 + '@vue/compiler-core@3.5.12': + dependencies: + '@babel/parser': 7.26.1 + '@vue/shared': 3.5.12 + entities: 4.5.0 + estree-walker: 2.0.2 + source-map-js: 1.2.1 + + '@vue/compiler-dom@3.5.12': + dependencies: + '@vue/compiler-core': 3.5.12 + '@vue/shared': 3.5.12 + + '@vue/compiler-sfc@3.5.12': + dependencies: + '@babel/parser': 7.26.1 + '@vue/compiler-core': 3.5.12 + '@vue/compiler-dom': 3.5.12 + '@vue/compiler-ssr': 3.5.12 + '@vue/shared': 3.5.12 + estree-walker: 2.0.2 + magic-string: 0.30.12 + postcss: 8.4.47 + source-map-js: 1.2.1 + + '@vue/compiler-ssr@3.5.12': + dependencies: + '@vue/compiler-dom': 3.5.12 + '@vue/shared': 3.5.12 + + '@vue/devtools-api@7.5.4': + dependencies: + '@vue/devtools-kit': 7.5.4 + + '@vue/devtools-kit@7.5.4': + dependencies: + '@vue/devtools-shared': 7.5.4 + birpc: 0.2.19 + hookable: 5.5.3 + mitt: 3.0.1 + perfect-debounce: 1.0.0 + speakingurl: 14.0.1 + superjson: 2.2.1 + + '@vue/devtools-shared@7.5.4': + dependencies: + rfdc: 1.4.1 + + '@vue/reactivity@3.5.12': + dependencies: + '@vue/shared': 3.5.12 + + '@vue/runtime-core@3.5.12': + dependencies: + '@vue/reactivity': 3.5.12 + '@vue/shared': 3.5.12 + + '@vue/runtime-dom@3.5.12': + dependencies: + '@vue/reactivity': 3.5.12 + '@vue/runtime-core': 3.5.12 + '@vue/shared': 3.5.12 + csstype: 3.1.3 + + '@vue/server-renderer@3.5.12(vue@3.5.12(typescript@5.6.3))': + dependencies: + '@vue/compiler-ssr': 3.5.12 + '@vue/shared': 3.5.12 + vue: 3.5.12(typescript@5.6.3) + + '@vue/shared@3.5.12': {} + + '@vueuse/core@11.1.0(vue@3.5.12(typescript@5.6.3))': + dependencies: + '@types/web-bluetooth': 0.0.20 + '@vueuse/metadata': 11.1.0 + '@vueuse/shared': 11.1.0(vue@3.5.12(typescript@5.6.3)) + vue-demi: 0.14.10(vue@3.5.12(typescript@5.6.3)) + transitivePeerDependencies: + - '@vue/composition-api' + - vue + + '@vueuse/integrations@11.1.0(focus-trap@7.6.0)(vue@3.5.12(typescript@5.6.3))': + dependencies: + '@vueuse/core': 11.1.0(vue@3.5.12(typescript@5.6.3)) + '@vueuse/shared': 11.1.0(vue@3.5.12(typescript@5.6.3)) + vue-demi: 0.14.10(vue@3.5.12(typescript@5.6.3)) + optionalDependencies: + focus-trap: 7.6.0 + transitivePeerDependencies: + - '@vue/composition-api' + - vue + + '@vueuse/metadata@11.1.0': {} + + '@vueuse/shared@11.1.0(vue@3.5.12(typescript@5.6.3))': + dependencies: + vue-demi: 0.14.10(vue@3.5.12(typescript@5.6.3)) + transitivePeerDependencies: + - '@vue/composition-api' + - vue + abab@2.0.6: {} acorn-globals@7.0.1: @@ -8141,6 +9814,12 @@ snapshots: transitivePeerDependencies: - supports-color + agent-base@7.1.1: + dependencies: + debug: 4.3.7 + transitivePeerDependencies: + - supports-color + aggregate-error@4.0.1: dependencies: clean-stack: 4.2.0 @@ -8175,6 +9854,24 @@ snapshots: require-from-string: 2.0.2 uri-js: 4.4.1 + algoliasearch@4.24.0: + dependencies: + '@algolia/cache-browser-local-storage': 4.24.0 + '@algolia/cache-common': 4.24.0 + '@algolia/cache-in-memory': 4.24.0 + '@algolia/client-account': 4.24.0 + '@algolia/client-analytics': 4.24.0 + '@algolia/client-common': 4.24.0 + '@algolia/client-personalization': 4.24.0 + '@algolia/client-search': 4.24.0 + '@algolia/logger-common': 4.24.0 + '@algolia/logger-console': 4.24.0 + '@algolia/recommend': 4.24.0 + '@algolia/requester-browser-xhr': 4.24.0 + '@algolia/requester-common': 4.24.0 + '@algolia/requester-node-http': 4.24.0 + '@algolia/transporter': 4.24.0 + ansi-align@3.0.1: dependencies: string-width: 4.2.3 @@ -8232,12 +9929,96 @@ snapshots: normalize-path: 3.0.0 picomatch: 2.3.1 - aqu@0.4.3(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(@types/node@22.8.1)(babel-jest@29.7.0(@babel/core@7.26.0)): + aqu@0.4.3(@babel/core@7.19.6)(@jest/transform@29.7.0)(@jest/types@29.6.3)(@types/node@18.19.60)(babel-jest@29.7.0(@babel/core@7.19.6))(babel-plugin-macros@3.1.0): + dependencies: + '@babel/preset-env': 7.26.0(@babel/core@7.19.6) + '@babel/preset-react': 7.25.9(@babel/core@7.19.6) + '@esbuild-plugins/node-resolve': 0.1.4(esbuild@0.15.18) + '@typescript-eslint/eslint-plugin': 5.62.0(@typescript-eslint/parser@5.62.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@4.8.4) + '@typescript-eslint/parser': 5.62.0(eslint@8.57.1)(typescript@4.8.4) + chalk: 4.1.2 + chokidar: 3.6.0 + commander: 9.5.0 + dts-bundle-generator: 6.13.0 + esbuild: 0.15.18 + eslint: 8.57.1 + eslint-config-prettier: 8.10.0(eslint@8.57.1) + eslint-plugin-prettier: 4.2.1(eslint-config-prettier@8.10.0(eslint@8.57.1))(eslint@8.57.1)(prettier@2.8.8) + eslint-plugin-simple-import-sort: 8.0.0(eslint@8.57.1) + execa: 4.1.0 + fs-extra: 10.1.0 + github-username: 6.0.0 + inquirer: 7.3.3 + jest: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) + jest-watch-typeahead: 2.2.2(jest@29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0)) + lodash: 4.17.21 + ora: 5.4.1 + prettier: 2.8.8 + rimraf: 3.0.2 + ts-jest: 29.2.5(@babel/core@7.19.6)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(esbuild@0.15.18)(jest@29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0))(typescript@4.8.4) + typescript: 4.8.4 + webpack-merge: 5.10.0 + yup: 0.32.11 + transitivePeerDependencies: + - '@babel/core' + - '@jest/transform' + - '@jest/types' + - '@types/node' + - babel-jest + - babel-plugin-macros + - encoding + - node-notifier + - supports-color + - ts-node + + aqu@0.4.3(@babel/core@7.19.6)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(babel-plugin-macros@3.1.0): + dependencies: + '@babel/preset-env': 7.26.0(@babel/core@7.19.6) + '@babel/preset-react': 7.25.9(@babel/core@7.19.6) + '@esbuild-plugins/node-resolve': 0.1.4(esbuild@0.15.18) + '@typescript-eslint/eslint-plugin': 5.62.0(@typescript-eslint/parser@5.62.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@4.8.4) + '@typescript-eslint/parser': 5.62.0(eslint@8.57.1)(typescript@4.8.4) + chalk: 4.1.2 + chokidar: 3.6.0 + commander: 9.5.0 + dts-bundle-generator: 6.13.0 + esbuild: 0.15.18 + eslint: 8.57.1 + eslint-config-prettier: 8.10.0(eslint@8.57.1) + eslint-plugin-prettier: 4.2.1(eslint-config-prettier@8.10.0(eslint@8.57.1))(eslint@8.57.1)(prettier@2.8.8) + eslint-plugin-simple-import-sort: 8.0.0(eslint@8.57.1) + execa: 4.1.0 + fs-extra: 10.1.0 + github-username: 6.0.0 + inquirer: 7.3.3 + jest: 29.7.0(babel-plugin-macros@3.1.0) + jest-watch-typeahead: 2.2.2(jest@29.7.0(babel-plugin-macros@3.1.0)) + lodash: 4.17.21 + ora: 5.4.1 + prettier: 2.8.8 + rimraf: 3.0.2 + ts-jest: 29.2.5(@babel/core@7.19.6)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(esbuild@0.15.18)(jest@29.7.0(babel-plugin-macros@3.1.0))(typescript@4.8.4) + typescript: 4.8.4 + webpack-merge: 5.10.0 + yup: 0.32.11 + transitivePeerDependencies: + - '@babel/core' + - '@jest/transform' + - '@jest/types' + - '@types/node' + - babel-jest + - babel-plugin-macros + - encoding + - node-notifier + - supports-color + - ts-node + + aqu@0.4.3(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(@types/node@22.8.2)(babel-jest@29.7.0(@babel/core@7.26.0)): dependencies: '@babel/preset-env': 7.26.0(@babel/core@7.26.0) '@babel/preset-react': 7.25.9(@babel/core@7.26.0) '@esbuild-plugins/node-resolve': 0.1.4(esbuild@0.15.18) - '@typescript-eslint/eslint-plugin': 5.62.0(@typescript-eslint/parser@5.62.0(eslint@8.57.1)(typescript@4.8.4))(eslint@8.57.1)(typescript@4.8.4) + '@typescript-eslint/eslint-plugin': 5.62.0(@typescript-eslint/parser@5.62.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@4.8.4) '@typescript-eslint/parser': 5.62.0(eslint@8.57.1)(typescript@4.8.4) chalk: 4.1.2 chokidar: 3.6.0 @@ -8252,13 +10033,13 @@ snapshots: fs-extra: 10.1.0 github-username: 6.0.0 inquirer: 7.3.3 - jest: 29.7.0(@types/node@22.8.1) - jest-watch-typeahead: 2.2.2(jest@29.7.0(@types/node@22.8.1)) + jest: 29.7.0(@types/node@22.8.2) + jest-watch-typeahead: 2.2.2(jest@29.7.0(@types/node@22.8.2)) lodash: 4.17.21 ora: 5.4.1 prettier: 2.8.8 rimraf: 3.0.2 - ts-jest: 29.2.5(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.0))(esbuild@0.15.18)(jest@29.7.0)(typescript@4.8.4) + ts-jest: 29.2.5(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.0))(esbuild@0.15.18)(jest@29.7.0(@types/node@22.8.2))(typescript@4.8.4) typescript: 4.8.4 webpack-merge: 5.10.0 yup: 0.32.11 @@ -8279,8 +10060,8 @@ snapshots: '@babel/preset-env': 7.26.0(@babel/core@7.26.0) '@babel/preset-react': 7.25.9(@babel/core@7.26.0) '@esbuild-plugins/node-resolve': 0.1.4(esbuild@0.15.18) - '@typescript-eslint/eslint-plugin': 5.62.0(@typescript-eslint/parser@5.62.0(eslint@8.57.1)(typescript@4.8.4))(eslint@8.57.1)(typescript@4.8.4) - '@typescript-eslint/parser': 5.62.0(eslint@9.13.0(jiti@2.3.3))(typescript@5.6.3) + '@typescript-eslint/eslint-plugin': 5.62.0(@typescript-eslint/parser@5.62.0(eslint@8.57.1)(typescript@5.6.3))(eslint@8.57.1)(typescript@4.8.4) + '@typescript-eslint/parser': 5.62.0(eslint@8.57.1)(typescript@4.8.4) chalk: 4.1.2 chokidar: 3.6.0 commander: 9.5.0 @@ -8294,8 +10075,8 @@ snapshots: fs-extra: 10.1.0 github-username: 6.0.0 inquirer: 7.3.3 - jest: 29.7.0(@types/node@22.8.1) - jest-watch-typeahead: 2.2.2(jest@29.7.0(@types/node@22.8.1)) + jest: 29.7.0 + jest-watch-typeahead: 2.2.2(jest@29.7.0) lodash: 4.17.21 ora: 5.4.1 prettier: 2.8.8 @@ -8322,6 +10103,10 @@ snapshots: argparse@2.0.1: {} + aria-query@5.3.0: + dependencies: + dequal: 2.0.3 + aria-query@5.3.2: {} array-buffer-byte-length@1.0.1: @@ -8403,6 +10188,19 @@ snapshots: dependencies: possible-typed-array-names: 1.0.0 + babel-jest@29.7.0(@babel/core@7.19.6): + dependencies: + '@babel/core': 7.19.6 + '@jest/transform': 29.7.0 + '@types/babel__core': 7.20.5 + babel-plugin-istanbul: 6.1.1 + babel-preset-jest: 29.6.3(@babel/core@7.19.6) + chalk: 4.1.2 + graceful-fs: 4.2.11 + slash: 3.0.0 + transitivePeerDependencies: + - supports-color + babel-jest@29.7.0(@babel/core@7.26.0): dependencies: '@babel/core': 7.26.0 @@ -8415,6 +10213,7 @@ snapshots: slash: 3.0.0 transitivePeerDependencies: - supports-color + optional: true babel-plugin-istanbul@6.1.1: dependencies: @@ -8433,6 +10232,22 @@ snapshots: '@types/babel__core': 7.20.5 '@types/babel__traverse': 7.20.6 + babel-plugin-macros@3.1.0: + dependencies: + '@babel/runtime': 7.26.0 + cosmiconfig: 7.1.0 + resolve: 1.22.8 + optional: true + + babel-plugin-polyfill-corejs2@0.4.11(@babel/core@7.19.6): + dependencies: + '@babel/compat-data': 7.26.0 + '@babel/core': 7.19.6 + '@babel/helper-define-polyfill-provider': 0.6.2(@babel/core@7.19.6) + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + babel-plugin-polyfill-corejs2@0.4.11(@babel/core@7.26.0): dependencies: '@babel/compat-data': 7.26.0 @@ -8442,6 +10257,14 @@ snapshots: transitivePeerDependencies: - supports-color + babel-plugin-polyfill-corejs3@0.10.6(@babel/core@7.19.6): + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-define-polyfill-provider': 0.6.2(@babel/core@7.19.6) + core-js-compat: 3.38.1 + transitivePeerDependencies: + - supports-color + babel-plugin-polyfill-corejs3@0.10.6(@babel/core@7.26.0): dependencies: '@babel/core': 7.26.0 @@ -8450,6 +10273,13 @@ snapshots: transitivePeerDependencies: - supports-color + babel-plugin-polyfill-regenerator@0.6.2(@babel/core@7.19.6): + dependencies: + '@babel/core': 7.19.6 + '@babel/helper-define-polyfill-provider': 0.6.2(@babel/core@7.19.6) + transitivePeerDependencies: + - supports-color + babel-plugin-polyfill-regenerator@0.6.2(@babel/core@7.26.0): dependencies: '@babel/core': 7.26.0 @@ -8457,6 +10287,25 @@ snapshots: transitivePeerDependencies: - supports-color + babel-preset-current-node-syntax@1.1.0(@babel/core@7.19.6): + dependencies: + '@babel/core': 7.19.6 + '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.19.6) + '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.19.6) + '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.19.6) + '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.19.6) + '@babel/plugin-syntax-import-attributes': 7.26.0(@babel/core@7.19.6) + '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.19.6) + '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.19.6) + '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.19.6) + '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.19.6) + '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.19.6) + '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.19.6) + '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.19.6) + '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.19.6) + '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.19.6) + '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.19.6) + babel-preset-current-node-syntax@1.1.0(@babel/core@7.26.0): dependencies: '@babel/core': 7.26.0 @@ -8475,12 +10324,20 @@ snapshots: '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.26.0) '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.26.0) '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.26.0) + optional: true + + babel-preset-jest@29.6.3(@babel/core@7.19.6): + dependencies: + '@babel/core': 7.19.6 + babel-plugin-jest-hoist: 29.6.3 + babel-preset-current-node-syntax: 1.1.0(@babel/core@7.19.6) babel-preset-jest@29.6.3(@babel/core@7.26.0): dependencies: '@babel/core': 7.26.0 babel-plugin-jest-hoist: 29.6.3 babel-preset-current-node-syntax: 1.1.0(@babel/core@7.26.0) + optional: true balanced-match@1.0.2: {} @@ -8496,6 +10353,8 @@ snapshots: binary-extensions@2.3.0: {} + birpc@0.2.19: {} + bl@4.1.0: dependencies: buffer: 5.7.1 @@ -8581,6 +10440,8 @@ snapshots: caniuse-lite@1.0.30001673: {} + ccount@2.0.1: {} + chai@5.1.2: dependencies: assertion-error: 2.0.1 @@ -8618,6 +10479,10 @@ snapshots: char-regex@2.0.1: {} + character-entities-html4@2.1.0: {} + + character-entities-legacy@3.0.0: {} + chardet@0.7.0: {} check-error@2.1.1: {} @@ -8739,6 +10604,8 @@ snapshots: dependencies: delayed-stream: 1.0.0 + comma-separated-tokens@2.0.3: {} + commander@10.0.1: {} commander@12.1.0: {} @@ -8756,6 +10623,10 @@ snapshots: ini: 1.3.8 proto-list: 1.2.4 + configs@https://codeload.github.com/fracht/configs/tar.gz/b8a8e13fc3db0f3d5afdcedd0749fccc7292be30: + dependencies: + lodash.mergewith: 4.6.2 + configstore@7.0.0: dependencies: atomically: 2.0.3 @@ -8765,14 +10636,29 @@ snapshots: consola@3.2.3: {} + convert-source-map@1.9.0: {} + convert-source-map@2.0.0: {} + copy-anything@3.0.5: + dependencies: + is-what: 4.1.16 + core-js-compat@3.38.1: dependencies: browserslist: 4.24.2 core-js@3.38.1: {} + cosmiconfig@7.1.0: + dependencies: + '@types/parse-json': 4.0.2 + import-fresh: 3.3.0 + parse-json: 5.2.0 + path-type: 4.0.0 + yaml: 1.10.2 + optional: true + cosmiconfig@8.3.6(typescript@5.6.3): dependencies: import-fresh: 3.3.0 @@ -8813,13 +10699,43 @@ snapshots: p-filter: 3.0.0 p-map: 6.0.0 - create-jest@29.7.0(@types/node@22.8.1): + create-jest@29.7.0: + dependencies: + '@jest/types': 29.6.3 + chalk: 4.1.2 + exit: 0.1.2 + graceful-fs: 4.2.11 + jest-config: 29.7.0(@types/node@18.19.60) + jest-util: 29.7.0 + prompts: 2.4.2 + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - supports-color + - ts-node + + create-jest@29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0): dependencies: '@jest/types': 29.6.3 chalk: 4.1.2 exit: 0.1.2 graceful-fs: 4.2.11 - jest-config: 29.7.0(@types/node@22.8.1) + jest-config: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) + jest-util: 29.7.0 + prompts: 2.4.2 + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - supports-color + - ts-node + + create-jest@29.7.0(@types/node@22.8.2): + dependencies: + '@jest/types': 29.6.3 + chalk: 4.1.2 + exit: 0.1.2 + graceful-fs: 4.2.11 + jest-config: 29.7.0(@types/node@22.8.2) jest-util: 29.7.0 prompts: 2.4.2 transitivePeerDependencies: @@ -8848,6 +10764,10 @@ snapshots: dependencies: cssom: 0.3.8 + cssstyle@4.1.0: + dependencies: + rrweb-cssom: 0.7.1 + csstype@3.1.3: {} danger@12.3.3: @@ -8899,6 +10819,11 @@ snapshots: whatwg-mimetype: 3.0.0 whatwg-url: 11.0.0 + data-urls@5.0.0: + dependencies: + whatwg-mimetype: 4.0.0 + whatwg-url: 14.0.0 + data-view-buffer@1.0.1: dependencies: call-bind: 1.0.7 @@ -8925,7 +10850,9 @@ snapshots: decimal.js@10.4.3: {} - dedent@1.5.3: {} + dedent@1.5.3(babel-plugin-macros@3.1.0): + optionalDependencies: + babel-plugin-macros: 3.1.0 deep-eql@5.0.2: {} @@ -8975,10 +10902,18 @@ snapshots: deprecation@2.3.1: {} + dequal@2.0.3: {} + detect-indent@6.1.0: {} detect-newline@3.1.0: {} + devlop@1.1.0: + dependencies: + dequal: 2.0.3 + + diff-sequences@26.6.2: {} + diff-sequences@29.6.3: {} dir-glob@3.0.1: @@ -9494,6 +11429,8 @@ snapshots: estraverse@5.3.0: {} + estree-walker@2.0.2: {} + estree-walker@3.0.3: dependencies: '@types/estree': 1.0.6 @@ -9658,6 +11595,10 @@ snapshots: flatted@3.3.1: {} + focus-trap@7.6.0: + dependencies: + tabbable: 6.2.0 + for-each@0.3.3: dependencies: is-callable: 1.2.7 @@ -9772,15 +11713,6 @@ snapshots: package-json-from-dist: 1.0.1 path-scurry: 1.11.1 - glob@11.0.0: - dependencies: - foreground-child: 3.3.0 - jackspeak: 4.0.2 - minimatch: 10.0.1 - minipass: 7.1.2 - package-json-from-dist: 1.0.1 - path-scurry: 2.0.0 - glob@7.2.3: dependencies: fs.realpath: 1.0.0 @@ -9843,6 +11775,13 @@ snapshots: graphemer@1.4.0: {} + happy-dom@15.7.4: + dependencies: + entities: 4.5.0 + webidl-conversions: 7.0.0 + whatwg-mimetype: 3.0.0 + optional: true + has-ansi@2.0.0: dependencies: ansi-regex: 2.1.1 @@ -9875,12 +11814,32 @@ snapshots: dependencies: function-bind: 1.1.2 + hast-util-to-html@9.0.3: + dependencies: + '@types/hast': 3.0.4 + '@types/unist': 3.0.3 + ccount: 2.0.1 + comma-separated-tokens: 2.0.3 + hast-util-whitespace: 3.0.0 + html-void-elements: 3.0.0 + mdast-util-to-hast: 13.2.0 + property-information: 6.5.0 + space-separated-tokens: 2.0.2 + stringify-entities: 4.0.4 + zwitch: 2.0.4 + + hast-util-whitespace@3.0.0: + dependencies: + '@types/hast': 3.0.4 + highlight.js@10.7.3: {} homedir-polyfill@1.0.3: dependencies: parse-passwd: 1.0.0 + hookable@5.5.3: {} + hosted-git-info@7.0.2: dependencies: lru-cache: 10.4.3 @@ -9889,8 +11848,14 @@ snapshots: dependencies: whatwg-encoding: 2.0.0 + html-encoding-sniffer@4.0.0: + dependencies: + whatwg-encoding: 3.1.1 + html-escaper@2.0.2: {} + html-void-elements@3.0.0: {} + http-proxy-agent@5.0.0: dependencies: '@tootallnate/once': 2.0.0 @@ -9899,6 +11864,13 @@ snapshots: transitivePeerDependencies: - supports-color + http-proxy-agent@7.0.2: + dependencies: + agent-base: 7.1.1 + debug: 4.3.7 + transitivePeerDependencies: + - supports-color + https-proxy-agent@5.0.1: dependencies: agent-base: 6.0.2 @@ -9906,6 +11878,13 @@ snapshots: transitivePeerDependencies: - supports-color + https-proxy-agent@7.0.5: + dependencies: + agent-base: 7.1.1 + debug: 4.3.7 + transitivePeerDependencies: + - supports-color + human-id@1.0.2: {} human-signals@1.1.1: {} @@ -10200,6 +12179,8 @@ snapshots: call-bind: 1.0.7 get-intrinsic: 1.2.4 + is-what@4.1.16: {} + is-windows@1.0.2: {} is-wsl@3.1.0: @@ -10218,7 +12199,7 @@ snapshots: istanbul-lib-instrument@5.2.1: dependencies: - '@babel/core': 7.26.0 + '@babel/core': 7.19.6 '@babel/parser': 7.26.1 '@istanbuljs/schema': 0.1.3 istanbul-lib-coverage: 3.2.2 @@ -10269,10 +12250,6 @@ snapshots: optionalDependencies: '@pkgjs/parseargs': 0.11.0 - jackspeak@4.0.2: - dependencies: - '@isaacs/cliui': 8.0.2 - jake@10.9.2: dependencies: async: 3.2.6 @@ -10286,16 +12263,16 @@ snapshots: jest-util: 29.7.0 p-limit: 3.1.0 - jest-circus@29.7.0: + jest-circus@29.7.0(babel-plugin-macros@3.1.0): dependencies: '@jest/environment': 29.7.0 '@jest/expect': 29.7.0 '@jest/test-result': 29.7.0 '@jest/types': 29.6.3 - '@types/node': 22.8.1 + '@types/node': 18.19.60 chalk: 4.1.2 co: 4.6.0 - dedent: 1.5.3 + dedent: 1.5.3(babel-plugin-macros@3.1.0) is-generator-fn: 2.1.0 jest-each: 29.7.0 jest-matcher-utils: 29.7.0 @@ -10312,16 +12289,16 @@ snapshots: - babel-plugin-macros - supports-color - jest-cli@29.7.0(@types/node@22.8.1): + jest-cli@29.7.0: dependencies: '@jest/core': 29.7.0 '@jest/test-result': 29.7.0 '@jest/types': 29.6.3 chalk: 4.1.2 - create-jest: 29.7.0(@types/node@22.8.1) + create-jest: 29.7.0 exit: 0.1.2 import-local: 3.2.0 - jest-config: 29.7.0(@types/node@22.8.1) + jest-config: 29.7.0(@types/node@18.19.60) jest-util: 29.7.0 jest-validate: 29.7.0 yargs: 17.7.2 @@ -10331,18 +12308,135 @@ snapshots: - supports-color - ts-node - jest-config@29.7.0(@types/node@22.8.1): + jest-cli@29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0): dependencies: - '@babel/core': 7.26.0 + '@jest/core': 29.7.0(babel-plugin-macros@3.1.0) + '@jest/test-result': 29.7.0 + '@jest/types': 29.6.3 + chalk: 4.1.2 + create-jest: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) + exit: 0.1.2 + import-local: 3.2.0 + jest-config: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) + jest-util: 29.7.0 + jest-validate: 29.7.0 + yargs: 17.7.2 + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - supports-color + - ts-node + + jest-cli@29.7.0(@types/node@22.8.2): + dependencies: + '@jest/core': 29.7.0 + '@jest/test-result': 29.7.0 + '@jest/types': 29.6.3 + chalk: 4.1.2 + create-jest: 29.7.0(@types/node@22.8.2) + exit: 0.1.2 + import-local: 3.2.0 + jest-config: 29.7.0(@types/node@22.8.2) + jest-util: 29.7.0 + jest-validate: 29.7.0 + yargs: 17.7.2 + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - supports-color + - ts-node + + jest-cli@29.7.0(babel-plugin-macros@3.1.0): + dependencies: + '@jest/core': 29.7.0(babel-plugin-macros@3.1.0) + '@jest/test-result': 29.7.0 + '@jest/types': 29.6.3 + chalk: 4.1.2 + create-jest: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) + exit: 0.1.2 + import-local: 3.2.0 + jest-config: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) + jest-util: 29.7.0 + jest-validate: 29.7.0 + yargs: 17.7.2 + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - supports-color + - ts-node + + jest-config@29.7.0(@types/node@18.19.60): + dependencies: + '@babel/core': 7.19.6 '@jest/test-sequencer': 29.7.0 '@jest/types': 29.6.3 - babel-jest: 29.7.0(@babel/core@7.26.0) + babel-jest: 29.7.0(@babel/core@7.19.6) + chalk: 4.1.2 + ci-info: 3.9.0 + deepmerge: 4.3.1 + glob: 7.2.3 + graceful-fs: 4.2.11 + jest-circus: 29.7.0(babel-plugin-macros@3.1.0) + jest-environment-node: 29.7.0 + jest-get-type: 29.6.3 + jest-regex-util: 29.6.3 + jest-resolve: 29.7.0 + jest-runner: 29.7.0 + jest-util: 29.7.0 + jest-validate: 29.7.0 + micromatch: 4.0.8 + parse-json: 5.2.0 + pretty-format: 29.7.0 + slash: 3.0.0 + strip-json-comments: 3.1.1 + optionalDependencies: + '@types/node': 18.19.60 + transitivePeerDependencies: + - babel-plugin-macros + - supports-color + + jest-config@29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0): + dependencies: + '@babel/core': 7.19.6 + '@jest/test-sequencer': 29.7.0 + '@jest/types': 29.6.3 + babel-jest: 29.7.0(@babel/core@7.19.6) + chalk: 4.1.2 + ci-info: 3.9.0 + deepmerge: 4.3.1 + glob: 7.2.3 + graceful-fs: 4.2.11 + jest-circus: 29.7.0(babel-plugin-macros@3.1.0) + jest-environment-node: 29.7.0 + jest-get-type: 29.6.3 + jest-regex-util: 29.6.3 + jest-resolve: 29.7.0 + jest-runner: 29.7.0 + jest-util: 29.7.0 + jest-validate: 29.7.0 + micromatch: 4.0.8 + parse-json: 5.2.0 + pretty-format: 29.7.0 + slash: 3.0.0 + strip-json-comments: 3.1.1 + optionalDependencies: + '@types/node': 18.19.60 + transitivePeerDependencies: + - babel-plugin-macros + - supports-color + + jest-config@29.7.0(@types/node@22.8.2): + dependencies: + '@babel/core': 7.19.6 + '@jest/test-sequencer': 29.7.0 + '@jest/types': 29.6.3 + babel-jest: 29.7.0(@babel/core@7.19.6) chalk: 4.1.2 ci-info: 3.9.0 deepmerge: 4.3.1 glob: 7.2.3 graceful-fs: 4.2.11 - jest-circus: 29.7.0 + jest-circus: 29.7.0(babel-plugin-macros@3.1.0) jest-environment-node: 29.7.0 jest-get-type: 29.6.3 jest-regex-util: 29.6.3 @@ -10356,11 +12450,18 @@ snapshots: slash: 3.0.0 strip-json-comments: 3.1.1 optionalDependencies: - '@types/node': 22.8.1 + '@types/node': 22.8.2 transitivePeerDependencies: - babel-plugin-macros - supports-color + jest-diff@26.6.2: + dependencies: + chalk: 4.1.2 + diff-sequences: 26.6.2 + jest-get-type: 26.3.0 + pretty-format: 26.6.2 + jest-diff@29.7.0: dependencies: chalk: 4.1.2 @@ -10380,13 +12481,13 @@ snapshots: jest-util: 29.7.0 pretty-format: 29.7.0 - jest-environment-jsdom@29.7.0: + jest-environment-jsdom@29.2.1: dependencies: '@jest/environment': 29.7.0 '@jest/fake-timers': 29.7.0 '@jest/types': 29.6.3 '@types/jsdom': 20.0.1 - '@types/node': 22.8.1 + '@types/node': 22.8.2 jest-mock: 29.7.0 jest-util: 29.7.0 jsdom: 20.0.3 @@ -10400,17 +12501,19 @@ snapshots: '@jest/environment': 29.7.0 '@jest/fake-timers': 29.7.0 '@jest/types': 29.6.3 - '@types/node': 22.8.1 + '@types/node': 18.19.60 jest-mock: 29.7.0 jest-util: 29.7.0 + jest-get-type@26.3.0: {} + jest-get-type@29.6.3: {} jest-haste-map@29.7.0: dependencies: '@jest/types': 29.6.3 '@types/graceful-fs': 4.1.9 - '@types/node': 22.8.1 + '@types/node': 18.19.60 anymatch: 3.1.3 fb-watchman: 2.0.2 graceful-fs: 4.2.11 @@ -10449,7 +12552,7 @@ snapshots: jest-mock@29.7.0: dependencies: '@jest/types': 29.6.3 - '@types/node': 22.8.1 + '@types/node': 22.8.2 jest-util: 29.7.0 jest-pnp-resolver@1.2.3(jest-resolve@29.7.0): @@ -10484,7 +12587,7 @@ snapshots: '@jest/test-result': 29.7.0 '@jest/transform': 29.7.0 '@jest/types': 29.6.3 - '@types/node': 22.8.1 + '@types/node': 18.19.60 chalk: 4.1.2 emittery: 0.13.1 graceful-fs: 4.2.11 @@ -10512,7 +12615,7 @@ snapshots: '@jest/test-result': 29.7.0 '@jest/transform': 29.7.0 '@jest/types': 29.6.3 - '@types/node': 22.8.1 + '@types/node': 18.19.60 chalk: 4.1.2 cjs-module-lexer: 1.4.1 collect-v8-coverage: 1.0.2 @@ -10532,15 +12635,15 @@ snapshots: jest-snapshot@29.7.0: dependencies: - '@babel/core': 7.26.0 + '@babel/core': 7.19.6 '@babel/generator': 7.26.0 - '@babel/plugin-syntax-jsx': 7.25.9(@babel/core@7.26.0) - '@babel/plugin-syntax-typescript': 7.25.9(@babel/core@7.26.0) + '@babel/plugin-syntax-jsx': 7.25.9(@babel/core@7.19.6) + '@babel/plugin-syntax-typescript': 7.25.9(@babel/core@7.19.6) '@babel/types': 7.26.0 '@jest/expect-utils': 29.7.0 '@jest/transform': 29.7.0 '@jest/types': 29.6.3 - babel-preset-current-node-syntax: 1.1.0(@babel/core@7.26.0) + babel-preset-current-node-syntax: 1.1.0(@babel/core@7.19.6) chalk: 4.1.2 expect: 29.7.0 graceful-fs: 4.2.11 @@ -10558,7 +12661,7 @@ snapshots: jest-util@29.7.0: dependencies: '@jest/types': 29.6.3 - '@types/node': 22.8.1 + '@types/node': 18.19.60 chalk: 4.1.2 ci-info: 3.9.0 graceful-fs: 4.2.11 @@ -10573,11 +12676,44 @@ snapshots: leven: 3.1.0 pretty-format: 29.7.0 - jest-watch-typeahead@2.2.2(jest@29.7.0(@types/node@22.8.1)): + jest-watch-typeahead@2.2.2(jest@29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0)): + dependencies: + ansi-escapes: 6.2.1 + chalk: 5.3.0 + jest: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) + jest-regex-util: 29.6.3 + jest-watcher: 29.7.0 + slash: 5.1.0 + string-length: 5.0.1 + strip-ansi: 7.1.0 + + jest-watch-typeahead@2.2.2(jest@29.7.0(@types/node@22.8.2)): + dependencies: + ansi-escapes: 6.2.1 + chalk: 5.3.0 + jest: 29.7.0(@types/node@22.8.2) + jest-regex-util: 29.6.3 + jest-watcher: 29.7.0 + slash: 5.1.0 + string-length: 5.0.1 + strip-ansi: 7.1.0 + + jest-watch-typeahead@2.2.2(jest@29.7.0(babel-plugin-macros@3.1.0)): + dependencies: + ansi-escapes: 6.2.1 + chalk: 5.3.0 + jest: 29.7.0(babel-plugin-macros@3.1.0) + jest-regex-util: 29.6.3 + jest-watcher: 29.7.0 + slash: 5.1.0 + string-length: 5.0.1 + strip-ansi: 7.1.0 + + jest-watch-typeahead@2.2.2(jest@29.7.0): dependencies: ansi-escapes: 6.2.1 chalk: 5.3.0 - jest: 29.7.0(@types/node@22.8.1) + jest: 29.7.0 jest-regex-util: 29.6.3 jest-watcher: 29.7.0 slash: 5.1.0 @@ -10588,7 +12724,7 @@ snapshots: dependencies: '@jest/test-result': 29.7.0 '@jest/types': 29.6.3 - '@types/node': 22.8.1 + '@types/node': 22.8.2 ansi-escapes: 4.3.2 chalk: 4.1.2 emittery: 0.13.1 @@ -10597,17 +12733,77 @@ snapshots: jest-worker@29.7.0: dependencies: - '@types/node': 22.8.1 + '@types/node': 18.19.60 jest-util: 29.7.0 merge-stream: 2.0.0 supports-color: 8.1.1 - jest@29.7.0(@types/node@22.8.1): + jest@29.2.2(@types/node@18.19.60)(babel-plugin-macros@3.1.0): + dependencies: + '@jest/core': 29.7.0(babel-plugin-macros@3.1.0) + '@jest/types': 29.6.3 + import-local: 3.2.0 + jest-cli: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - supports-color + - ts-node + + jest@29.2.2(babel-plugin-macros@3.1.0): + dependencies: + '@jest/core': 29.7.0(babel-plugin-macros@3.1.0) + '@jest/types': 29.6.3 + import-local: 3.2.0 + jest-cli: 29.7.0(babel-plugin-macros@3.1.0) + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - supports-color + - ts-node + + jest@29.7.0: + dependencies: + '@jest/core': 29.7.0 + '@jest/types': 29.6.3 + import-local: 3.2.0 + jest-cli: 29.7.0 + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - supports-color + - ts-node + + jest@29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0): + dependencies: + '@jest/core': 29.7.0(babel-plugin-macros@3.1.0) + '@jest/types': 29.6.3 + import-local: 3.2.0 + jest-cli: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - supports-color + - ts-node + + jest@29.7.0(@types/node@22.8.2): + dependencies: + '@jest/core': 29.7.0 + '@jest/types': 29.6.3 + import-local: 3.2.0 + jest-cli: 29.7.0(@types/node@22.8.2) + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - supports-color + - ts-node + + jest@29.7.0(babel-plugin-macros@3.1.0): dependencies: - '@jest/core': 29.7.0 + '@jest/core': 29.7.0(babel-plugin-macros@3.1.0) '@jest/types': 29.6.3 import-local: 3.2.0 - jest-cli: 29.7.0(@types/node@22.8.1) + jest-cli: 29.7.0(babel-plugin-macros@3.1.0) transitivePeerDependencies: - '@types/node' - babel-plugin-macros @@ -10664,6 +12860,34 @@ snapshots: - supports-color - utf-8-validate + jsdom@25.0.1: + dependencies: + cssstyle: 4.1.0 + data-urls: 5.0.0 + decimal.js: 10.4.3 + form-data: 4.0.1 + html-encoding-sniffer: 4.0.0 + http-proxy-agent: 7.0.2 + https-proxy-agent: 7.0.5 + is-potential-custom-element-name: 1.0.1 + nwsapi: 2.2.13 + parse5: 7.2.1 + rrweb-cssom: 0.7.1 + saxes: 6.0.0 + symbol-tree: 3.2.4 + tough-cookie: 5.0.0 + w3c-xmlserializer: 5.0.0 + webidl-conversions: 7.0.0 + whatwg-encoding: 3.1.1 + whatwg-mimetype: 4.0.0 + whatwg-url: 14.0.0 + ws: 8.18.0 + xml-name-validator: 5.0.0 + transitivePeerDependencies: + - bufferutil + - supports-color + - utf-8-validate + jsesc@3.0.2: {} json-buffer@3.0.1: {} @@ -10803,6 +13027,8 @@ snapshots: dependencies: p-locate: 5.0.0 + lodash-es@4.17.15: {} + lodash-es@4.17.21: {} lodash.debounce@4.0.8: {} @@ -10831,6 +13057,8 @@ snapshots: lodash.merge@4.6.2: {} + lodash.mergewith@4.6.2: {} + lodash.once@4.1.1: {} lodash.sortby@4.7.0: {} @@ -10869,8 +13097,6 @@ snapshots: lru-cache@10.4.3: {} - lru-cache@11.0.1: {} - lru-cache@4.1.5: dependencies: pseudomap: 1.0.2 @@ -10900,6 +13126,8 @@ snapshots: dependencies: tmpl: 1.0.5 + mark.js@8.11.1: {} + marked-terminal@7.1.0(marked@9.1.6): dependencies: ansi-escapes: 7.0.0 @@ -10912,6 +13140,18 @@ snapshots: marked@9.1.6: {} + mdast-util-to-hast@13.2.0: + dependencies: + '@types/hast': 3.0.4 + '@types/mdast': 4.0.4 + '@ungap/structured-clone': 1.2.0 + devlop: 1.1.0 + micromark-util-sanitize-uri: 2.0.0 + trim-lines: 3.0.1 + unist-util-position: 5.0.0 + unist-util-visit: 5.0.0 + vfile: 6.0.3 + memfs-or-file-map-to-github-branch@1.2.1: dependencies: '@octokit/rest': 18.12.0 @@ -10926,6 +13166,23 @@ snapshots: merge2@1.4.1: {} + micromark-util-character@2.1.0: + dependencies: + micromark-util-symbol: 2.0.0 + micromark-util-types: 2.0.0 + + micromark-util-encode@2.0.0: {} + + micromark-util-sanitize-uri@2.0.0: + dependencies: + micromark-util-character: 2.1.0 + micromark-util-encode: 2.0.0 + micromark-util-symbol: 2.0.0 + + micromark-util-symbol@2.0.0: {} + + micromark-util-types@2.0.0: {} + micromatch@4.0.8: dependencies: braces: 3.0.3 @@ -10945,10 +13202,6 @@ snapshots: mimic-function@5.0.1: {} - minimatch@10.0.1: - dependencies: - brace-expansion: 2.0.1 - minimatch@3.0.8: dependencies: brace-expansion: 1.1.11 @@ -10969,6 +13222,10 @@ snapshots: minipass@7.1.2: {} + minisearch@7.1.0: {} + + mitt@3.0.1: {} + mri@1.2.0: {} ms@2.1.3: {} @@ -11156,6 +13413,10 @@ snapshots: dependencies: mimic-function: 5.0.1 + oniguruma-to-js@0.4.3: + dependencies: + regex: 4.3.3 + open@10.1.0: dependencies: default-browser: 5.2.1 @@ -11326,11 +13587,6 @@ snapshots: lru-cache: 10.4.3 minipass: 7.1.2 - path-scurry@2.0.0: - dependencies: - lru-cache: 11.0.1 - minipass: 7.1.2 - path-type@4.0.0: {} path-type@5.0.0: {} @@ -11339,6 +13595,8 @@ snapshots: pathval@2.0.0: {} + perfect-debounce@1.0.0: {} + picocolors@1.1.1: {} picomatch@2.3.1: {} @@ -11376,6 +13634,8 @@ snapshots: picocolors: 1.1.1 source-map-js: 1.2.1 + preact@10.24.3: {} + prelude-ls@1.2.1: {} prettier-linter-helpers@1.0.0: @@ -11386,6 +13646,13 @@ snapshots: prettier@3.3.3: {} + pretty-format@26.6.2: + dependencies: + '@jest/types': 26.6.2 + ansi-regex: 5.0.1 + ansi-styles: 4.3.0 + react-is: 17.0.2 + pretty-format@27.5.1: dependencies: ansi-regex: 5.0.1 @@ -11418,6 +13685,8 @@ snapshots: property-expr@2.0.6: {} + property-information@6.5.0: {} + proto-list@1.2.4: {} pseudomap@1.0.2: {} @@ -11437,11 +13706,6 @@ snapshots: pure-rand@6.1.0: {} - pxth@0.7.0: - dependencies: - lodash: 4.17.21 - tiny-invariant: 1.3.3 - qs@6.13.0: dependencies: side-channel: 1.0.6 @@ -11457,6 +13721,12 @@ snapshots: minimist: 1.2.8 strip-json-comments: 2.0.1 + react-dom@18.2.0(react@18.2.0): + dependencies: + loose-envify: 1.4.0 + react: 18.2.0 + scheduler: 0.23.2 + react-dom@18.3.1(react@18.3.1): dependencies: loose-envify: 1.4.0 @@ -11469,6 +13739,10 @@ snapshots: react-is@18.3.1: {} + react@18.2.0: + dependencies: + loose-envify: 1.4.0 + react@18.3.1: dependencies: loose-envify: 1.4.0 @@ -11537,6 +13811,8 @@ snapshots: dependencies: '@babel/runtime': 7.26.0 + regex@4.3.3: {} + regexp.prototype.flags@1.5.3: dependencies: call-bind: 1.0.7 @@ -11620,15 +13896,12 @@ snapshots: reusify@1.0.4: {} + rfdc@1.4.1: {} + rimraf@3.0.2: dependencies: glob: 7.2.3 - rimraf@6.0.1: - dependencies: - glob: 11.0.0 - package-json-from-dist: 1.0.1 - rollup@4.24.2: dependencies: '@types/estree': 1.0.6 @@ -11653,6 +13926,8 @@ snapshots: '@rollup/rollup-win32-x64-msvc': 4.24.2 fsevents: 2.3.3 + rrweb-cssom@0.7.1: {} + run-applescript@7.0.0: {} run-async@2.4.1: {} @@ -11669,7 +13944,7 @@ snapshots: rxjs@7.8.1: dependencies: - tslib: 2.8.0 + tslib: 2.3.1 safe-array-concat@1.1.2: dependencies: @@ -11698,6 +13973,8 @@ snapshots: scoped-regex@3.0.0: {} + search-insights@2.17.2: {} + semver@6.3.1: {} semver@7.5.4: @@ -11738,6 +14015,15 @@ snapshots: shebang-regex@3.0.0: {} + shiki@1.22.2: + dependencies: + '@shikijs/core': 1.22.2 + '@shikijs/engine-javascript': 1.22.2 + '@shikijs/engine-oniguruma': 1.22.2 + '@shikijs/types': 1.22.2 + '@shikijs/vscode-textmate': 9.3.0 + '@types/hast': 3.0.4 + side-channel@1.0.6: dependencies: call-bind: 1.0.7 @@ -11788,6 +14074,8 @@ snapshots: dependencies: whatwg-url: 7.1.0 + space-separated-tokens@2.0.2: {} + spawndamnit@2.0.0: dependencies: cross-spawn: 5.1.0 @@ -11807,6 +14095,8 @@ snapshots: spdx-license-ids@3.0.12: {} + speakingurl@14.0.1: {} + sprintf-js@1.0.3: {} stack-utils@2.0.6: @@ -11819,14 +14109,6 @@ snapshots: stdin-discarder@0.2.2: {} - stocked@1.0.0-beta.33(react@18.3.1): - dependencies: - lodash: 4.17.21 - lodash-es: 4.17.21 - pxth: 0.7.0 - react: 18.3.1 - tiny-invariant: 1.3.3 - string-argv@0.3.2: {} string-length@4.0.2: @@ -11911,6 +14193,11 @@ snapshots: dependencies: safe-buffer: 5.2.1 + stringify-entities@4.0.4: + dependencies: + character-entities-html4: 2.1.0 + character-entities-legacy: 3.0.0 + strip-ansi@3.0.1: dependencies: ansi-regex: 2.1.1 @@ -11955,6 +14242,10 @@ snapshots: pirates: 4.0.5 ts-interface-checker: 0.1.13 + superjson@2.2.1: + dependencies: + copy-anything: 3.0.5 + supports-color@2.0.0: {} supports-color@5.5.0: @@ -12020,6 +14311,8 @@ snapshots: transitivePeerDependencies: - typescript + tabbable@6.2.0: {} + term-size@2.2.1: {} terminal-link@3.0.0: @@ -12047,7 +14340,7 @@ snapshots: tightrope@0.2.0: {} - tiny-case@1.0.3: {} + tiny-invariant@1.2.0: {} tiny-invariant@1.3.3: {} @@ -12066,6 +14359,12 @@ snapshots: tinyspy@3.0.2: {} + tldts-core@6.1.57: {} + + tldts@6.1.57: + dependencies: + tldts-core: 6.1.57 + tmp@0.0.33: dependencies: os-tmpdir: 1.0.2 @@ -12085,6 +14384,10 @@ snapshots: universalify: 0.2.0 url-parse: 1.5.10 + tough-cookie@5.0.0: + dependencies: + tldts: 6.1.57 + tr46@0.0.3: {} tr46@1.0.1: @@ -12095,26 +14398,106 @@ snapshots: dependencies: punycode: 2.3.1 + tr46@5.0.0: + dependencies: + punycode: 2.3.1 + tree-kill@1.2.2: {} + trim-lines@3.0.1: {} + ts-api-utils@1.3.0(typescript@5.6.3): dependencies: typescript: 5.6.3 ts-interface-checker@0.1.13: {} - ts-jest@29.2.5(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.0))(esbuild@0.15.18)(jest@29.7.0(@types/node@22.8.1))(typescript@5.6.3): + ts-jest@29.0.3(@babel/core@7.19.6)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(jest@29.2.2(@types/node@18.19.60)(babel-plugin-macros@3.1.0))(typescript@4.8.4): + dependencies: + bs-logger: 0.2.6 + fast-json-stable-stringify: 2.1.0 + jest: 29.2.2(@types/node@18.19.60)(babel-plugin-macros@3.1.0) + jest-util: 29.7.0 + json5: 2.2.3 + lodash.memoize: 4.1.2 + make-error: 1.3.6 + semver: 7.6.3 + typescript: 4.8.4 + yargs-parser: 21.1.1 + optionalDependencies: + '@babel/core': 7.19.6 + '@jest/types': 29.6.3 + babel-jest: 29.7.0(@babel/core@7.19.6) + + ts-jest@29.0.3(@babel/core@7.19.6)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(jest@29.2.2(babel-plugin-macros@3.1.0))(typescript@4.8.4): + dependencies: + bs-logger: 0.2.6 + fast-json-stable-stringify: 2.1.0 + jest: 29.2.2(babel-plugin-macros@3.1.0) + jest-util: 29.7.0 + json5: 2.2.3 + lodash.memoize: 4.1.2 + make-error: 1.3.6 + semver: 7.6.3 + typescript: 4.8.4 + yargs-parser: 21.1.1 + optionalDependencies: + '@babel/core': 7.19.6 + '@jest/types': 29.6.3 + babel-jest: 29.7.0(@babel/core@7.19.6) + + ts-jest@29.2.5(@babel/core@7.19.6)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(esbuild@0.15.18)(jest@29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0))(typescript@4.8.4): dependencies: bs-logger: 0.2.6 ejs: 3.1.10 fast-json-stable-stringify: 2.1.0 - jest: 29.7.0(@types/node@22.8.1) + jest: 29.7.0(@types/node@18.19.60)(babel-plugin-macros@3.1.0) jest-util: 29.7.0 json5: 2.2.3 lodash.memoize: 4.1.2 make-error: 1.3.6 semver: 7.6.3 - typescript: 5.6.3 + typescript: 4.8.4 + yargs-parser: 21.1.1 + optionalDependencies: + '@babel/core': 7.19.6 + '@jest/transform': 29.7.0 + '@jest/types': 29.6.3 + babel-jest: 29.7.0(@babel/core@7.19.6) + esbuild: 0.15.18 + + ts-jest@29.2.5(@babel/core@7.19.6)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.19.6))(esbuild@0.15.18)(jest@29.7.0(babel-plugin-macros@3.1.0))(typescript@4.8.4): + dependencies: + bs-logger: 0.2.6 + ejs: 3.1.10 + fast-json-stable-stringify: 2.1.0 + jest: 29.7.0(babel-plugin-macros@3.1.0) + jest-util: 29.7.0 + json5: 2.2.3 + lodash.memoize: 4.1.2 + make-error: 1.3.6 + semver: 7.6.3 + typescript: 4.8.4 + yargs-parser: 21.1.1 + optionalDependencies: + '@babel/core': 7.19.6 + '@jest/transform': 29.7.0 + '@jest/types': 29.6.3 + babel-jest: 29.7.0(@babel/core@7.19.6) + esbuild: 0.15.18 + + ts-jest@29.2.5(@babel/core@7.26.0)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.0))(esbuild@0.15.18)(jest@29.7.0(@types/node@22.8.2))(typescript@4.8.4): + dependencies: + bs-logger: 0.2.6 + ejs: 3.1.10 + fast-json-stable-stringify: 2.1.0 + jest: 29.7.0(@types/node@22.8.2) + jest-util: 29.7.0 + json5: 2.2.3 + lodash.memoize: 4.1.2 + make-error: 1.3.6 + semver: 7.6.3 + typescript: 4.8.4 yargs-parser: 21.1.1 optionalDependencies: '@babel/core': 7.26.0 @@ -12128,7 +14511,7 @@ snapshots: bs-logger: 0.2.6 ejs: 3.1.10 fast-json-stable-stringify: 2.1.0 - jest: 29.7.0(@types/node@22.8.1) + jest: 29.7.0 jest-util: 29.7.0 json5: 2.2.3 lodash.memoize: 4.1.2 @@ -12147,9 +14530,11 @@ snapshots: tslib@1.14.1: {} + tslib@2.3.1: {} + tslib@2.8.0: {} - tsup@8.3.5(@microsoft/api-extractor@7.47.11(@types/node@22.8.1))(jiti@2.3.3)(postcss@8.4.47)(typescript@5.6.3): + tsup@8.3.5(@microsoft/api-extractor@7.47.11(@types/node@20.17.2))(jiti@2.3.3)(postcss@8.4.47)(typescript@5.6.3): dependencies: bundle-require: 5.0.0(esbuild@0.24.0) cac: 6.7.14 @@ -12168,7 +14553,7 @@ snapshots: tinyglobby: 0.2.10 tree-kill: 1.2.2 optionalDependencies: - '@microsoft/api-extractor': 7.47.11(@types/node@22.8.1) + '@microsoft/api-extractor': 7.47.11(@types/node@20.17.2) postcss: 8.4.47 typescript: 5.6.3 transitivePeerDependencies: @@ -12274,6 +14659,8 @@ snapshots: has-symbols: 1.0.3 which-boxed-primitive: 1.0.2 + undici-types@5.26.5: {} + undici-types@6.19.8: {} unicode-canonical-property-names-ecmascript@2.0.1: {} @@ -12291,6 +14678,29 @@ snapshots: unicorn-magic@0.1.0: {} + unist-util-is@6.0.0: + dependencies: + '@types/unist': 3.0.3 + + unist-util-position@5.0.0: + dependencies: + '@types/unist': 3.0.3 + + unist-util-stringify-position@4.0.0: + dependencies: + '@types/unist': 3.0.3 + + unist-util-visit-parents@6.0.1: + dependencies: + '@types/unist': 3.0.3 + unist-util-is: 6.0.0 + + unist-util-visit@5.0.0: + dependencies: + '@types/unist': 3.0.3 + unist-util-is: 6.0.0 + unist-util-visit-parents: 6.0.1 + universal-user-agent@6.0.1: {} universal-user-agent@7.0.2: {} @@ -12344,12 +14754,39 @@ snapshots: validate-npm-package-name@5.0.1: {} - vite-node@2.1.4(@types/node@22.8.1): + vfile-message@4.0.2: + dependencies: + '@types/unist': 3.0.3 + unist-util-stringify-position: 4.0.0 + + vfile@6.0.3: + dependencies: + '@types/unist': 3.0.3 + vfile-message: 4.0.2 + + vite-node@2.1.4(@types/node@20.17.2): + dependencies: + cac: 6.7.14 + debug: 4.3.7 + pathe: 1.1.2 + vite: 5.4.10(@types/node@20.17.2) + transitivePeerDependencies: + - '@types/node' + - less + - lightningcss + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + + vite-node@2.1.4(@types/node@22.8.2): dependencies: cac: 6.7.14 debug: 4.3.7 pathe: 1.1.2 - vite: 5.4.10(@types/node@22.8.1) + vite: 5.4.10(@types/node@22.8.2) transitivePeerDependencies: - '@types/node' - less @@ -12361,19 +14798,77 @@ snapshots: - supports-color - terser - vite@5.4.10(@types/node@22.8.1): + vite@5.4.10(@types/node@20.17.2): + dependencies: + esbuild: 0.21.5 + postcss: 8.4.47 + rollup: 4.24.2 + optionalDependencies: + '@types/node': 20.17.2 + fsevents: 2.3.3 + + vite@5.4.10(@types/node@22.8.2): dependencies: esbuild: 0.21.5 postcss: 8.4.47 rollup: 4.24.2 optionalDependencies: - '@types/node': 22.8.1 + '@types/node': 22.8.2 fsevents: 2.3.3 - vitest@2.1.4(@types/node@22.8.1)(jsdom@20.0.3): + vitepress@1.4.1(@algolia/client-search@4.24.0)(@types/node@22.8.2)(@types/react@18.3.12)(postcss@8.4.47)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(search-insights@2.17.2)(typescript@5.6.3): + dependencies: + '@docsearch/css': 3.6.2 + '@docsearch/js': 3.6.2(@algolia/client-search@4.24.0)(@types/react@18.3.12)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(search-insights@2.17.2) + '@shikijs/core': 1.22.2 + '@shikijs/transformers': 1.22.2 + '@shikijs/types': 1.22.2 + '@types/markdown-it': 14.1.2 + '@vitejs/plugin-vue': 5.1.4(vite@5.4.10(@types/node@22.8.2))(vue@3.5.12(typescript@5.6.3)) + '@vue/devtools-api': 7.5.4 + '@vue/shared': 3.5.12 + '@vueuse/core': 11.1.0(vue@3.5.12(typescript@5.6.3)) + '@vueuse/integrations': 11.1.0(focus-trap@7.6.0)(vue@3.5.12(typescript@5.6.3)) + focus-trap: 7.6.0 + mark.js: 8.11.1 + minisearch: 7.1.0 + shiki: 1.22.2 + vite: 5.4.10(@types/node@22.8.2) + vue: 3.5.12(typescript@5.6.3) + optionalDependencies: + postcss: 8.4.47 + transitivePeerDependencies: + - '@algolia/client-search' + - '@types/node' + - '@types/react' + - '@vue/composition-api' + - async-validator + - axios + - change-case + - drauu + - fuse.js + - idb-keyval + - jwt-decode + - less + - lightningcss + - nprogress + - qrcode + - react + - react-dom + - sass + - sass-embedded + - search-insights + - sortablejs + - stylus + - sugarss + - terser + - typescript + - universal-cookie + + vitest@2.1.4(@types/node@20.17.2)(happy-dom@15.7.4)(jsdom@25.0.1): dependencies: '@vitest/expect': 2.1.4 - '@vitest/mocker': 2.1.4(vite@5.4.10(@types/node@22.8.1)) + '@vitest/mocker': 2.1.4(vite@5.4.10(@types/node@20.17.2)) '@vitest/pretty-format': 2.1.4 '@vitest/runner': 2.1.4 '@vitest/snapshot': 2.1.4 @@ -12389,12 +14884,50 @@ snapshots: tinyexec: 0.3.1 tinypool: 1.0.1 tinyrainbow: 1.2.0 - vite: 5.4.10(@types/node@22.8.1) - vite-node: 2.1.4(@types/node@22.8.1) + vite: 5.4.10(@types/node@20.17.2) + vite-node: 2.1.4(@types/node@20.17.2) why-is-node-running: 2.3.0 optionalDependencies: - '@types/node': 22.8.1 - jsdom: 20.0.3 + '@types/node': 20.17.2 + happy-dom: 15.7.4 + jsdom: 25.0.1 + transitivePeerDependencies: + - less + - lightningcss + - msw + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + + vitest@2.1.4(@types/node@22.8.2)(happy-dom@15.7.4)(jsdom@25.0.1): + dependencies: + '@vitest/expect': 2.1.4 + '@vitest/mocker': 2.1.4(vite@5.4.10(@types/node@22.8.2)) + '@vitest/pretty-format': 2.1.4 + '@vitest/runner': 2.1.4 + '@vitest/snapshot': 2.1.4 + '@vitest/spy': 2.1.4 + '@vitest/utils': 2.1.4 + chai: 5.1.2 + debug: 4.3.7 + expect-type: 1.1.0 + magic-string: 0.30.12 + pathe: 1.1.2 + std-env: 3.7.0 + tinybench: 2.9.0 + tinyexec: 0.3.1 + tinypool: 1.0.1 + tinyrainbow: 1.2.0 + vite: 5.4.10(@types/node@22.8.2) + vite-node: 2.1.4(@types/node@22.8.2) + why-is-node-running: 2.3.0 + optionalDependencies: + '@types/node': 22.8.2 + happy-dom: 15.7.4 + jsdom: 25.0.1 transitivePeerDependencies: - less - lightningcss @@ -12406,10 +14939,28 @@ snapshots: - supports-color - terser + vue-demi@0.14.10(vue@3.5.12(typescript@5.6.3)): + dependencies: + vue: 3.5.12(typescript@5.6.3) + + vue@3.5.12(typescript@5.6.3): + dependencies: + '@vue/compiler-dom': 3.5.12 + '@vue/compiler-sfc': 3.5.12 + '@vue/runtime-dom': 3.5.12 + '@vue/server-renderer': 3.5.12(vue@3.5.12(typescript@5.6.3)) + '@vue/shared': 3.5.12 + optionalDependencies: + typescript: 5.6.3 + w3c-xmlserializer@4.0.0: dependencies: xml-name-validator: 4.0.0 + w3c-xmlserializer@5.0.0: + dependencies: + xml-name-validator: 5.0.0 + walker@1.0.8: dependencies: makeerror: 1.0.12 @@ -12434,13 +14985,24 @@ snapshots: dependencies: iconv-lite: 0.6.3 + whatwg-encoding@3.1.1: + dependencies: + iconv-lite: 0.6.3 + whatwg-mimetype@3.0.0: {} + whatwg-mimetype@4.0.0: {} + whatwg-url@11.0.0: dependencies: tr46: 3.0.0 webidl-conversions: 7.0.0 + whatwg-url@14.0.0: + dependencies: + tr46: 5.0.0 + webidl-conversions: 7.0.0 + whatwg-url@5.0.0: dependencies: tr46: 0.0.3 @@ -12557,6 +15119,8 @@ snapshots: xml-name-validator@4.0.0: {} + xml-name-validator@5.0.0: {} + xmlchars@2.2.0: {} xtend@4.0.2: {} @@ -12569,6 +15133,9 @@ snapshots: yallist@4.0.0: {} + yaml@1.10.2: + optional: true + yargs-parser@20.2.9: {} yargs-parser@21.1.1: {} @@ -12607,9 +15174,14 @@ snapshots: property-expr: 2.0.6 toposort: 2.0.2 - yup@1.4.0: + yup@0.32.9: dependencies: + '@babel/runtime': 7.26.0 + '@types/lodash': 4.17.12 + lodash: 4.17.21 + lodash-es: 4.17.15 + nanoclone: 0.2.1 property-expr: 2.0.6 - tiny-case: 1.0.3 toposort: 2.0.2 - type-fest: 2.19.0 + + zwitch@2.0.4: {}