@legendapp/state 3.0.0-alpha.1 → 3.0.0-alpha.3

package/react-hooks/useObservableNextRouter.d.mts

@@ -0,0 +1,35 @@
+import { Observable } from '@legendapp/state';
+import { NextRouter } from 'next/router';
+
+type ParsedUrlQuery = {
+    [key: string]: string | string[] | undefined;
+};
+interface TransitionOptions {
+    shallow?: boolean;
+    locale?: string | false;
+    scroll?: boolean;
+    unstable_skipClientCache?: boolean;
+}
+interface ObservableNextRouterState {
+    pathname: string;
+    hash: string;
+    query: ParsedUrlQuery;
+}
+type RouteInfo = Partial<ObservableNextRouterState>;
+interface ParamsUseObservableNextRouterBase {
+    transitionOptions?: TransitionOptions;
+    method?: 'push' | 'replace';
+    subscribe?: boolean;
+}
+interface ParamsUseObservableNextRouter<T extends object> extends ParamsUseObservableNextRouterBase {
+    compute: (value: ObservableNextRouterState) => T;
+    set: (value: T, previous: T, router: NextRouter) => RouteInfo & {
+        transitionOptions?: TransitionOptions;
+        method?: 'push' | 'replace';
+    };
+}
+declare function useObservableNextRouter(): Observable<ObservableNextRouterState>;
+declare function useObservableNextRouter<T extends object>(params: ParamsUseObservableNextRouter<T>): Observable<T>;
+declare function useObservableNextRouter(params: ParamsUseObservableNextRouterBase): Observable<ObservableNextRouterState>;
+
+export { type ObservableNextRouterState, type ParamsUseObservableNextRouter, type ParamsUseObservableNextRouterBase, useObservableNextRouter };

package/react-hooks/useObservableNextRouter.d.ts

@@ -1,5 +1,6 @@
 import { Observable } from '@legendapp/state';
 import { NextRouter } from 'next/router';
+
 type ParsedUrlQuery = {
     [key: string]: string | string[] | undefined;
 };
@@ -9,25 +10,26 @@ interface TransitionOptions {
     scroll?: boolean;
     unstable_skipClientCache?: boolean;
 }
-export interface ObservableNextRouterState {
+interface ObservableNextRouterState {
     pathname: string;
     hash: string;
     query: ParsedUrlQuery;
 }
 type RouteInfo = Partial<ObservableNextRouterState>;
-export interface ParamsUseObservableNextRouterBase {
+interface ParamsUseObservableNextRouterBase {
     transitionOptions?: TransitionOptions;
     method?: 'push' | 'replace';
     subscribe?: boolean;
 }
-export interface ParamsUseObservableNextRouter<T extends object> extends ParamsUseObservableNextRouterBase {
+interface ParamsUseObservableNextRouter<T extends object> extends ParamsUseObservableNextRouterBase {
     compute: (value: ObservableNextRouterState) => T;
     set: (value: T, previous: T, router: NextRouter) => RouteInfo & {
         transitionOptions?: TransitionOptions;
         method?: 'push' | 'replace';
     };
 }
-export declare function useObservableNextRouter(): Observable<ObservableNextRouterState>;
-export declare function useObservableNextRouter<T extends object>(params: ParamsUseObservableNextRouter<T>): Observable<T>;
-export declare function useObservableNextRouter(params: ParamsUseObservableNextRouterBase): Observable<ObservableNextRouterState>;
-export {};
+declare function useObservableNextRouter(): Observable<ObservableNextRouterState>;
+declare function useObservableNextRouter<T extends object>(params: ParamsUseObservableNextRouter<T>): Observable<T>;
+declare function useObservableNextRouter(params: ParamsUseObservableNextRouterBase): Observable<ObservableNextRouterState>;
+
+export { type ObservableNextRouterState, type ParamsUseObservableNextRouter, type ParamsUseObservableNextRouterBase, useObservableNextRouter };

package/react-hooks/useObservableNextRouter.js

@@ -3,90 +3,77 @@
 var state = require('@legendapp/state');
 var Router = require('next/router');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Router__default = /*#__PURE__*/_interopDefault(Router);
+
+// src/react-hooks/useObservableNextRouter.ts
 function isShallowEqual(query1, query2) {
-    if (!query1 !== !query2) {
-        return false;
-    }
-    const keys1 = Object.keys(query1);
-    const keys2 = Object.keys(query2);
-    if (keys1.length !== keys2.length) {
-        return false;
+  if (!query1 !== !query2) {
+    return false;
+  }
+  const keys1 = Object.keys(query1);
+  const keys2 = Object.keys(query2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (query1[key] !== query2[key]) {
+      return false;
     }
-    for (const key of keys1) {
-        if (query1[key] !== query2[key]) {
-            return false;
-        }
-    }
-    return true;
+  }
+  return true;
 }
-const routes$ = state.observable({});
-let routeParams = {};
-let router;
+var routes$ = state.observable({});
+var routeParams = {};
+var router;
 routes$.onChange(({ value, getPrevious }) => {
-    // Only run this if being manually changed by the user
-    let setter = routeParams === null || routeParams === void 0 ? void 0 : routeParams.set;
-    if (!setter) {
-        if (value.pathname) {
-            setter = () => value;
-        }
-        else {
-            console.error('[legend-state]: Must provide a set method to useObservableNextRouter');
-        }
-    }
-    const setReturn = setter(value, getPrevious(), router);
-    const { pathname, hash, query } = setReturn;
-    let { transitionOptions, method } = setReturn;
-    method = method || (routeParams === null || routeParams === void 0 ? void 0 : routeParams.method);
-    transitionOptions = transitionOptions || (routeParams === null || routeParams === void 0 ? void 0 : routeParams.transitionOptions);
-    const prevHash = router.asPath.split('#')[1] || '';
-    const change = {};
-    // Only include changes that were meant to be changed. For example the user may have
-    // only changed the hash so we don't need to push a pathname change.
-    if (pathname !== undefined && pathname !== router.pathname) {
-        change.pathname = pathname;
-    }
-    if (hash !== undefined && hash !== prevHash) {
-        change.hash = hash;
-    }
-    if (query !== undefined && !isShallowEqual(query, router.query)) {
-        change.query = query;
-    }
-    // Only push if there are changes
-    if (!state.isEmpty(change)) {
-        const fn = method === 'replace' ? 'replace' : 'push';
-        router[fn](change, undefined, transitionOptions).catch((e) => {
-            // workaround for https://github.com/vercel/next.js/issues/37362
-            if (!e.cancelled)
-                throw e;
-        });
+  let setter = routeParams == null ? void 0 : routeParams.set;
+  if (!setter) {
+    if (value.pathname) {
+      setter = () => value;
+    } else {
+      console.error("[legend-state]: Must provide a set method to useObservableNextRouter");
     }
+  }
+  const setReturn = setter(value, getPrevious(), router);
+  const { pathname, hash, query } = setReturn;
+  let { transitionOptions, method } = setReturn;
+  method = method || (routeParams == null ? void 0 : routeParams.method);
+  transitionOptions = transitionOptions || (routeParams == null ? void 0 : routeParams.transitionOptions);
+  const prevHash = router.asPath.split("#")[1] || "";
+  const change = {};
+  if (pathname !== void 0 && pathname !== router.pathname) {
+    change.pathname = pathname;
+  }
+  if (hash !== void 0 && hash !== prevHash) {
+    change.hash = hash;
+  }
+  if (query !== void 0 && !isShallowEqual(query, router.query)) {
+    change.query = query;
+  }
+  if (!state.isEmpty(change)) {
+    const fn = method === "replace" ? "replace" : "push";
+    router[fn](change, void 0, transitionOptions).catch((e) => {
+      if (!e.cancelled)
+        throw e;
+    });
+  }
 });
 function useObservableNextRouter(params) {
-    const { subscribe, compute } = params || {};
-    try {
-        // Use the useRouter hook if we're on the client side and want to subscribe to changes.
-        // Otherwise use the Router object so that this does not subscribe to router changes.
-        router = typeof window !== 'undefined' && !subscribe ? Router : Router.useRouter();
-    }
-    finally {
-        router = router || Router.useRouter();
-    }
-    // Update the local state with the new functions and options. This can happen when being run
-    // on a new page or if the user just changes it on the current page.
-    // It's better for performance than creating new observables or hooks for every use, since there may be
-    // many uses of useObservableRouter in the lifecycle of a page.
-    routeParams = params;
-    // Get the pathname and hash
-    const { asPath, pathname, query } = router;
-    const hash = asPath.split('#')[1] || '';
-    // Run the compute function to get the value of the object
-    const computeParams = { pathname, hash, query };
-    const obj = compute ? compute(computeParams) : computeParams;
-    // Set the object without triggering router.push
-    state.setSilently(routes$, obj);
-    // Return the observable with the computed values
-    return routes$;
+  const { subscribe, compute } = params || {};
+  try {
+    router = typeof window !== "undefined" && !subscribe ? Router__default.default : Router.useRouter();
+  } finally {
+    router = router || Router.useRouter();
+  }
+  routeParams = params;
+  const { asPath, pathname, query } = router;
+  const hash = asPath.split("#")[1] || "";
+  const computeParams = { pathname, hash, query };
+  const obj = compute ? compute(computeParams) : computeParams;
+  state.setSilently(routes$, obj);
+  return routes$;
 }
 
 exports.useObservableNextRouter = useObservableNextRouter;
-//# sourceMappingURL=useObservableNextRouter.js.map

package/react-hooks/useObservableNextRouter.mjs

@@ -1,90 +1,73 @@
 import { observable, isEmpty, setSilently } from '@legendapp/state';
 import Router, { useRouter } from 'next/router';
 
+// src/react-hooks/useObservableNextRouter.ts
 function isShallowEqual(query1, query2) {
-    if (!query1 !== !query2) {
-        return false;
+  if (!query1 !== !query2) {
+    return false;
+  }
+  const keys1 = Object.keys(query1);
+  const keys2 = Object.keys(query2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (query1[key] !== query2[key]) {
+      return false;
     }
-    const keys1 = Object.keys(query1);
-    const keys2 = Object.keys(query2);
-    if (keys1.length !== keys2.length) {
-        return false;
-    }
-    for (const key of keys1) {
-        if (query1[key] !== query2[key]) {
-            return false;
-        }
-    }
-    return true;
+  }
+  return true;
 }
-const routes$ = observable({});
-let routeParams = {};
-let router;
+var routes$ = observable({});
+var routeParams = {};
+var router;
 routes$.onChange(({ value, getPrevious }) => {
-    // Only run this if being manually changed by the user
-    let setter = routeParams === null || routeParams === void 0 ? void 0 : routeParams.set;
-    if (!setter) {
-        if (value.pathname) {
-            setter = () => value;
-        }
-        else {
-            console.error('[legend-state]: Must provide a set method to useObservableNextRouter');
-        }
-    }
-    const setReturn = setter(value, getPrevious(), router);
-    const { pathname, hash, query } = setReturn;
-    let { transitionOptions, method } = setReturn;
-    method = method || (routeParams === null || routeParams === void 0 ? void 0 : routeParams.method);
-    transitionOptions = transitionOptions || (routeParams === null || routeParams === void 0 ? void 0 : routeParams.transitionOptions);
-    const prevHash = router.asPath.split('#')[1] || '';
-    const change = {};
-    // Only include changes that were meant to be changed. For example the user may have
-    // only changed the hash so we don't need to push a pathname change.
-    if (pathname !== undefined && pathname !== router.pathname) {
-        change.pathname = pathname;
-    }
-    if (hash !== undefined && hash !== prevHash) {
-        change.hash = hash;
-    }
-    if (query !== undefined && !isShallowEqual(query, router.query)) {
-        change.query = query;
-    }
-    // Only push if there are changes
-    if (!isEmpty(change)) {
-        const fn = method === 'replace' ? 'replace' : 'push';
-        router[fn](change, undefined, transitionOptions).catch((e) => {
-            // workaround for https://github.com/vercel/next.js/issues/37362
-            if (!e.cancelled)
-                throw e;
-        });
+  let setter = routeParams == null ? void 0 : routeParams.set;
+  if (!setter) {
+    if (value.pathname) {
+      setter = () => value;
+    } else {
+      console.error("[legend-state]: Must provide a set method to useObservableNextRouter");
     }
+  }
+  const setReturn = setter(value, getPrevious(), router);
+  const { pathname, hash, query } = setReturn;
+  let { transitionOptions, method } = setReturn;
+  method = method || (routeParams == null ? void 0 : routeParams.method);
+  transitionOptions = transitionOptions || (routeParams == null ? void 0 : routeParams.transitionOptions);
+  const prevHash = router.asPath.split("#")[1] || "";
+  const change = {};
+  if (pathname !== void 0 && pathname !== router.pathname) {
+    change.pathname = pathname;
+  }
+  if (hash !== void 0 && hash !== prevHash) {
+    change.hash = hash;
+  }
+  if (query !== void 0 && !isShallowEqual(query, router.query)) {
+    change.query = query;
+  }
+  if (!isEmpty(change)) {
+    const fn = method === "replace" ? "replace" : "push";
+    router[fn](change, void 0, transitionOptions).catch((e) => {
+      if (!e.cancelled)
+        throw e;
+    });
+  }
 });
 function useObservableNextRouter(params) {
-    const { subscribe, compute } = params || {};
-    try {
-        // Use the useRouter hook if we're on the client side and want to subscribe to changes.
-        // Otherwise use the Router object so that this does not subscribe to router changes.
-        router = typeof window !== 'undefined' && !subscribe ? Router : useRouter();
-    }
-    finally {
-        router = router || useRouter();
-    }
-    // Update the local state with the new functions and options. This can happen when being run
-    // on a new page or if the user just changes it on the current page.
-    // It's better for performance than creating new observables or hooks for every use, since there may be
-    // many uses of useObservableRouter in the lifecycle of a page.
-    routeParams = params;
-    // Get the pathname and hash
-    const { asPath, pathname, query } = router;
-    const hash = asPath.split('#')[1] || '';
-    // Run the compute function to get the value of the object
-    const computeParams = { pathname, hash, query };
-    const obj = compute ? compute(computeParams) : computeParams;
-    // Set the object without triggering router.push
-    setSilently(routes$, obj);
-    // Return the observable with the computed values
-    return routes$;
+  const { subscribe, compute } = params || {};
+  try {
+    router = typeof window !== "undefined" && !subscribe ? Router : useRouter();
+  } finally {
+    router = router || useRouter();
+  }
+  routeParams = params;
+  const { asPath, pathname, query } = router;
+  const hash = asPath.split("#")[1] || "";
+  const computeParams = { pathname, hash, query };
+  const obj = compute ? compute(computeParams) : computeParams;
+  setSilently(routes$, obj);
+  return routes$;
 }
 
 export { useObservableNextRouter };
-//# sourceMappingURL=useObservableNextRouter.mjs.map

package/react.d.mts

@@ -0,0 +1,157 @@
+import * as react from 'react';
+import { ReactNode, ReactElement, FC, LegacyRef, ComponentClass, ReducerWithoutAction, ReducerStateWithoutAction, DispatchWithoutAction, Reducer, ReducerState, Dispatch, ReducerAction } from 'react';
+import { ObservableParam, Observable, ObservableBoolean, Selector, RecursiveValueOrFunction, ObserveEvent, ObserveOptions, ObserveEventCallback } from '@legendapp/state';
+
+declare function Computed({ children }: {
+    children: ObservableParam | (() => ReactNode);
+}): ReactElement;
+
+type ForItemProps<T, TProps = {}> = {
+    item$: Observable<T>;
+    id?: string;
+} & TProps;
+declare function For<T, TProps>({ each, optimized: isOptimized, item, itemProps, sortValues, children, }: {
+    each?: ObservableParam<T[] | Record<any, T> | Map<any, T>>;
+    optimized?: boolean;
+    item?: FC<ForItemProps<T, TProps>>;
+    itemProps?: TProps;
+    sortValues?: (A: T, B: T, AKey: string, BKey: string) => number;
+    children?: (value: Observable<T>, id: string | undefined) => ReactElement;
+}): ReactElement | null;
+
+declare function usePauseProvider(): {
+    PauseProvider: ({ children }: {
+        children: ReactNode;
+    }) => react.FunctionComponentElement<react.ProviderProps<ObservableBoolean>>;
+    isPaused$: ObservableBoolean;
+};
+
+declare const Memo: react.MemoExoticComponent<typeof Computed>;
+
+type ShapeWithNew$<T> = Partial<Omit<T, 'children'>> & {
+    [K in keyof T as K extends `$${string & K}` ? K : `$${string & K}`]?: Selector<T[K]>;
+} & {
+    children?: Selector<ReactNode>;
+};
+interface BindKey<P> {
+    handler?: keyof P;
+    getValue?: (e: any) => any;
+    defaultValue?: any;
+    selector?: (propsOut: Record<string, any>, p: Observable<any>) => any;
+}
+type BindKeys<P = any> = Record<keyof P, BindKey<P>>;
+type FCReactiveObject<T> = {
+    [K in keyof T]: FC<ShapeWithNew$<T[K]>>;
+};
+type FCReactive<P, P2> = P & FC<ShapeWithNew$<P2> & {
+    ref?: LegacyRef<P> | undefined;
+}>;
+interface UseSelectorOptions {
+    suspense?: boolean;
+    skipCheck?: boolean;
+}
+
+interface IReactive {
+}
+declare const Reactive: IReactive;
+declare function configureReactive({ components, binders, }: {
+    components?: Record<string, FC | ComponentClass<any>>;
+    binders?: Record<string, BindKeys>;
+}): void;
+
+interface PropsIf<T> {
+    if: Selector<T>;
+    ifReady?: never;
+}
+interface PropsIfReady<T> {
+    if?: never;
+    ifReady: Selector<T>;
+}
+interface PropsBase<T> {
+    else?: ReactNode | (() => ReactNode);
+    wrap?: FC;
+    children: ReactNode | ((value?: T) => ReactNode);
+}
+type Props<T> = PropsBase<T> & (PropsIf<T> | PropsIfReady<T>);
+declare function Show<T>(props: Props<T>): ReactElement;
+
+declare function Switch<T extends object>({ value, children, }: {
+    value?: Selector<T>;
+    children: Partial<Record<keyof T | 'null' | 'undefined' | 'default', () => ReactNode>>;
+}): ReactElement | null;
+declare function Switch<T extends string | number | symbol>({ value, children, }: {
+    value?: Selector<T>;
+    children: Partial<Record<T | 'null' | 'undefined' | 'default', () => ReactNode>>;
+}): ReactElement | null;
+declare function Switch<T extends boolean>({ value, children, }: {
+    value?: Selector<T>;
+    children: Partial<Record<'false' | 'true' | 'null' | 'undefined' | 'default', () => ReactNode>>;
+}): ReactElement | null;
+declare function Switch<T>({ value, children, }: {
+    value?: Selector<T>;
+    children: Partial<Record<'undefined' | 'default', () => ReactNode>>;
+}): ReactElement | null;
+
+type ShapeWithPick$<T, T2 extends keyof T = keyof T> = Partial<T> & {
+    [K in T2 as K extends `$${string & K}` ? K : `$${string & K}`]?: Selector<T[K]>;
+};
+type ShapeWith$<T> = Partial<T> & {
+    [K in keyof T as K extends `$${string & K}` ? K : `$${string & K}`]?: Selector<T[K]>;
+};
+type ObjectShapeWith$<T> = {
+    [K in keyof T]: T[K] extends FC<infer P> ? FC<ShapeWith$<P>> : T[K];
+};
+type ExtractFCPropsType<T> = T extends FC<infer P> ? P : never;
+declare const hasSymbol: false | ((key: string) => symbol);
+declare function observer<P extends FC<any>>(component: P): P;
+declare function reactive<T extends FC<any>>(component: T, bindKeys?: BindKeys<ExtractFCPropsType<T>>): T | FC<ShapeWith$<ExtractFCPropsType<T>>>;
+declare function reactive<T extends FC<any>, T2 extends keyof ExtractFCPropsType<T>>(component: T, bindKeys?: BindKeys<ExtractFCPropsType<T>>): T | FC<ShapeWithPick$<ExtractFCPropsType<T>, T2>>;
+declare function reactiveObserver<T extends FC<any>>(component: T, bindKeys?: BindKeys<ExtractFCPropsType<T>>): T | FC<ShapeWith$<ExtractFCPropsType<T>>>;
+declare function reactiveObserver<T extends FC<any>, T2 extends keyof ExtractFCPropsType<T>>(component: T, bindKeys?: BindKeys<ExtractFCPropsType<T>>): T | FC<ShapeWithPick$<ExtractFCPropsType<T>, T2>>;
+declare function reactiveComponents<P extends Record<string, FC>>(components: P): ObjectShapeWith$<P>;
+
+declare function useComputed<T>(compute: () => T | Promise<T>): Observable<T>;
+declare function useComputed<T>(compute: () => T | Promise<T>, deps: any[]): Observable<T>;
+declare function useComputed<T, T2 = T>(compute: (() => T | Promise<T>) | ObservableParam<T>, set: (value: T2) => void): Observable<T>;
+declare function useComputed<T, T2 = T>(compute: (() => T | Promise<T>) | ObservableParam<T>, set: (value: T2) => void, deps: any[]): Observable<T>;
+
+declare const useEffectOnce: (effect: () => void | (() => void), deps: any[]) => void;
+
+declare function useIsMounted(): Observable<boolean>;
+
+declare function useMount(fn: () => (void | (() => void)) | Promise<void>): void;
+declare const useMountOnce: typeof useMount;
+
+/**
+ * A React hook that creates a new observable
+ *
+ * @param initialValue The initial value of the observable or a function that returns the initial value
+ *
+ * @see https://www.legendapp.com/dev/state/react/#useObservable
+ */
+declare function useObservable<T>(): Observable<T | undefined>;
+declare function useObservable<T>(value: Promise<RecursiveValueOrFunction<T>> | (() => RecursiveValueOrFunction<T>) | RecursiveValueOrFunction<T>): Observable<T>;
+declare function useObservable<T>(value: T): Observable<T>;
+declare function useObservable<T>(value?: T): Observable<any>;
+
+declare function useObservableReducer<R extends ReducerWithoutAction<any>, I>(reducer: R, initializerArg: I, initializer: (arg: I) => ReducerStateWithoutAction<R>): [Observable<ReducerStateWithoutAction<R>>, DispatchWithoutAction];
+declare function useObservableReducer<R extends ReducerWithoutAction<any>>(reducer: R, initializerArg: ReducerStateWithoutAction<R>, initializer?: undefined): [Observable<ReducerStateWithoutAction<R>>, DispatchWithoutAction];
+declare function useObservableReducer<R extends Reducer<any, any>, I>(reducer: R, initializerArg: I & ReducerState<R>, initializer: (arg: I & ReducerState<R>) => ReducerState<R>): [Observable<ReducerState<R>>, Dispatch<ReducerAction<R>>];
+declare function useObservableReducer<R extends Reducer<any, any>, I>(reducer: R, initializerArg: I, initializer: (arg: I) => ReducerState<R>): [Observable<ReducerState<R>>, Dispatch<ReducerAction<R>>];
+declare function useObservableReducer<R extends Reducer<any, any>>(reducer: R, initialState: ReducerState<R>, initializer?: undefined): [Observable<ReducerState<R>>, Dispatch<ReducerAction<R>>];
+
+declare function useObserve<T>(run: (e: ObserveEvent<T>) => T | void, options?: ObserveOptions): () => void;
+declare function useObserve<T>(selector: Selector<T>, reaction?: (e: ObserveEventCallback<T>) => any, options?: ObserveOptions): () => void;
+
+declare function useObserveEffect<T>(run: (e: ObserveEvent<T>) => T | void, options?: ObserveOptions): void;
+declare function useObserveEffect<T>(selector: Selector<T>, reaction?: (e: ObserveEventCallback<T>) => any, options?: ObserveOptions): void;
+
+declare function useSelector<T>(selector: Selector<T>, options?: UseSelectorOptions): T;
+
+declare function useUnmount(fn: () => void): void;
+declare const useUnmountOnce: typeof useUnmount;
+
+declare function useWhen<T>(predicate: Selector<T>, effect: (value: T) => any | (() => any)): Promise<any>;
+declare function useWhenReady<T>(predicate: Selector<T>, effect: (value: T) => any | (() => any)): Promise<any>;
+
+export { type BindKey, type BindKeys, Computed, type ExtractFCPropsType, type FCReactive, type FCReactiveObject, For, type IReactive, Memo, type ObjectShapeWith$, Reactive, type ShapeWith$, type ShapeWithNew$, type ShapeWithPick$, Show, Switch, type UseSelectorOptions, configureReactive, hasSymbol, observer, reactive, reactiveComponents, reactiveObserver, useComputed, useEffectOnce, useIsMounted, useMount, useMountOnce, useObservable, useObservableReducer, useObserve, useObserveEffect, usePauseProvider, useSelector, useUnmount, useUnmountOnce, useWhen, useWhenReady };