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

package/src/sync-plugins/supabase.ts

@@ -1,249 +0,0 @@
-import { Observable, computeSelector, isObject, observable, symbolDelete } from '@legendapp/state';
-import {
-    SyncTransform,
-    SyncedOptions,
-    SyncedOptionsGlobal,
-    combineTransforms,
-    removeNullUndefined,
-    transformStringifyDates,
-    type SyncedGetParams,
-    type SyncedSubscribeParams,
-} from '@legendapp/state/sync';
-import {
-    CrudAsOption,
-    SyncedCrudPropsBase,
-    SyncedCrudPropsMany,
-    SyncedCrudReturnType,
-    syncedCrud,
-} from '@legendapp/state/sync-plugins/crud';
-import type { PostgrestFilterBuilder, PostgrestQueryBuilder } from '@supabase/postgrest-js';
-import type { SupabaseClient } from '@supabase/supabase-js';
-// Unused types but maybe useful in the future so keeping them for now
-// type DatabaseOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer TDB> ? TDB : never;
-// type SchemaNameOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer _, infer SchemaName>
-//     ? SchemaName
-//     : never;
-
-export type SupabaseSchemaOf<Client extends SupabaseClient> = Client extends SupabaseClient<
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    infer _,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    infer __,
-    infer Schema
->
-    ? Schema
-    : never;
-export type SupabaseTableOf<Client extends SupabaseClient> = SupabaseSchemaOf<Client>['Tables'];
-export type SupabaseCollectionOf<Client extends SupabaseClient> = keyof SupabaseTableOf<Client>;
-export type SupabaseRowOf<
-    Client extends SupabaseClient,
-    Collection extends SupabaseCollectionOf<Client>,
-> = SupabaseTableOf<Client>[Collection]['Row'];
-
-export type SyncedSupabaseConfig<TRemote extends { id: string | number }, TLocal> = Omit<
-    SyncedCrudPropsBase<TRemote, TLocal>,
-    'create' | 'update' | 'delete'
->;
-
-export interface SyncedSupabaseConfiguration
-    extends Omit<
-        SyncedSupabaseConfig<{ id: string | number }, { id: string | number }>,
-        'persist' | keyof SyncedOptions
-    > {
-    persist?: SyncedOptionsGlobal;
-    enabled?: Observable<boolean>;
-    as?: Exclude<CrudAsOption, 'value'>;
-}
-
-interface SyncedSupabaseProps<
-    Client extends SupabaseClient,
-    Collection extends SupabaseCollectionOf<Client>,
-    TOption extends CrudAsOption = 'object',
-    TRemote extends SupabaseRowOf<Client, Collection> = SupabaseRowOf<Client, Collection>,
-    TLocal = TRemote,
-> extends SyncedSupabaseConfig<TRemote, TLocal>,
-        SyncedCrudPropsMany<TRemote, TRemote, TOption> {
-    supabase: Client;
-    collection: Collection;
-    select?: (
-        query: PostgrestQueryBuilder<SupabaseSchemaOf<Client>, SupabaseTableOf<Client>[Collection], Collection>,
-    ) => PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>;
-    filter?: (
-        select: PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>,
-        params: SyncedGetParams,
-    ) => PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>;
-    actions?: ('create' | 'read' | 'update' | 'delete')[];
-    realtime?: boolean | { schema?: string; filter?: string };
-    stringifyDates?: boolean;
-}
-
-let channelNum = 1;
-const supabaseConfig: SyncedSupabaseConfiguration = {};
-const isEnabled$ = observable(true);
-
-export function getSyncedSupabaseConfiguration() {
-    return supabaseConfig;
-}
-export function configureSyncedSupabase(config: SyncedSupabaseConfiguration) {
-    const { enabled, ...rest } = config;
-    if (enabled !== undefined) {
-        isEnabled$.set(enabled);
-    }
-    Object.assign(supabaseConfig, removeNullUndefined(rest));
-}
-
-export function syncedSupabase<
-    Client extends SupabaseClient,
-    Collection extends SupabaseCollectionOf<Client> & string,
-    AsOption extends CrudAsOption = 'object',
-    TRemote extends SupabaseRowOf<Client, Collection> = SupabaseRowOf<Client, Collection>,
-    TLocal = TRemote,
->(props: SyncedSupabaseProps<Client, Collection, AsOption, TRemote, TLocal>): SyncedCrudReturnType<TLocal, AsOption> {
-    props = { ...supabaseConfig, ...props } as any;
-    const {
-        supabase: client,
-        collection,
-        select: selectFn,
-        filter,
-        actions,
-        fieldCreatedAt: fieldCreatedAtParam,
-        fieldUpdatedAt: fieldUpdatedAtParam,
-        fieldDeleted: fieldDeletedParam,
-        realtime,
-        changesSince,
-        transform: transformParam,
-        stringifyDates,
-        waitFor,
-        waitForSet,
-        generateId,
-        ...rest
-    } = props;
-
-    // If using last-sync mode then put it into soft delete mode
-    const fieldCreatedAt = fieldCreatedAtParam || (changesSince === 'last-sync' ? 'created_at' : undefined);
-    const fieldUpdatedAt = fieldUpdatedAtParam || (changesSince === 'last-sync' ? 'updated_at' : undefined);
-    const fieldDeleted = fieldDeletedParam || (changesSince === 'last-sync' ? 'deleted' : undefined);
-
-    const list =
-        !actions || actions.includes('read')
-            ? async (params: SyncedGetParams) => {
-                  const { lastSync } = params;
-                  const from = client.from(collection);
-                  let select = selectFn ? selectFn(from) : from.select();
-
-                  // in last-sync mode, filter for rows updated more recently than the last sync
-                  if (changesSince === 'last-sync' && lastSync) {
-                      const date = new Date(lastSync).toISOString();
-                      select = select.gt(fieldUpdatedAt!, date);
-                  }
-                  // filter with filter parameter
-                  if (filter) {
-                      select = filter(select, params);
-                  }
-                  const { data, error } = await select;
-                  if (error) {
-                      throw new Error(error?.message);
-                  }
-                  return (data! || []) as SupabaseRowOf<Client, Collection>[];
-              }
-            : undefined;
-
-    const upsert = async (input: SupabaseRowOf<Client, Collection>) => {
-        const res = await client.from(collection).upsert(input).select();
-        const { data, error } = res;
-        if (data) {
-            const created = data[0];
-            return created;
-        } else {
-            throw new Error(error?.message);
-        }
-    };
-    const create = !actions || actions.includes('create') ? upsert : undefined;
-    const update = !actions || actions.includes('update') ? upsert : undefined;
-    const deleteFn =
-        !fieldDeleted && (!actions || actions.includes('delete'))
-            ? async (input: { id: SupabaseRowOf<Client, Collection>['id'] }) => {
-                  const id = input.id;
-                  const res = await client.from(collection).delete().eq('id', id).select();
-                  const { data, error } = res;
-                  if (data) {
-                      const created = data[0];
-                      return created;
-                  } else {
-                      throw new Error(error?.message);
-                  }
-              }
-            : undefined;
-    const subscribe = realtime
-        ? ({ node, value$, update }: SyncedSubscribeParams) => {
-              const { filter, schema } = (isObject(realtime) ? realtime : {}) as { schema?: string; filter?: string };
-              const channel = client
-                  .channel(`LS_${node.key || ''}${channelNum++}`)
-                  .on(
-                      'postgres_changes',
-                      {
-                          event: '*',
-                          table: collection,
-                          schema: schema || 'public',
-                          filter: filter || undefined,
-                      },
-                      (payload) => {
-                          const { eventType, new: value, old } = payload;
-                          if (eventType === 'INSERT' || eventType === 'UPDATE') {
-                              const cur = value$.peek()?.[value.id];
-                              const curDateStr =
-                                  cur &&
-                                  ((fieldUpdatedAt && cur[fieldUpdatedAt]) ||
-                                      fieldCreatedAt ||
-                                      cur[fieldCreatedAt as any]);
-                              const valueDateStr =
-                                  (fieldUpdatedAt && value[fieldUpdatedAt]) ||
-                                  (fieldCreatedAt && value[fieldCreatedAt]);
-                              const valueDate = +new Date(valueDateStr);
-                              // Check if new or newer than last seen locally
-                              if (valueDateStr && (!curDateStr || valueDate > +new Date(curDateStr))) {
-                                  // Update local with the new value
-                                  update({
-                                      value: { [value.id]: value },
-                                      lastSync: valueDate,
-                                      mode: 'merge',
-                                  });
-                              }
-                          } else if (eventType === 'DELETE') {
-                              const { id } = old;
-                              update({
-                                  value: { [id]: symbolDelete },
-                              });
-                          }
-                      },
-                  )
-                  .subscribe();
-
-              return channel.unsubscribe;
-          }
-        : undefined;
-
-    let transform = transformParam;
-    if (stringifyDates) {
-        const stringifier = transformStringifyDates() as SyncTransform<TLocal, TRemote>;
-        transform = transform ? combineTransforms(stringifier, transform) : stringifier;
-    }
-
-    return syncedCrud<SupabaseRowOf<Client, Collection>, SupabaseRowOf<Client, Collection>, AsOption>({
-        ...rest,
-        list,
-        create,
-        update,
-        delete: deleteFn,
-        subscribe,
-        fieldCreatedAt,
-        fieldUpdatedAt,
-        fieldDeleted,
-        updatePartial: false,
-        onSavedUpdate: 'createdUpdatedAt',
-        transform,
-        generateId,
-        waitFor: () => isEnabled$.get() && (waitFor ? computeSelector(waitFor) : true),
-        waitForSet,
-    });
-}

package/src/sync-plugins/tanstack-query.ts

@@ -1,113 +0,0 @@
-import { isFunction, observe } from '@legendapp/state';
-import { SyncedOptions, SyncedSetParams, SyncedSubscribeParams, synced } from '@legendapp/state/sync';
-import {
-    DefaultError,
-    DefaultedQueryObserverOptions,
-    MutationObserver,
-    MutationObserverOptions,
-    QueryClient,
-    QueryKey,
-    QueryObserver,
-    QueryObserverOptions,
-    notifyManager,
-} from '@tanstack/query-core';
-
-export interface ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey extends QueryKey>
-    extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'> {
-    queryKey?: TQueryKey | (() => TQueryKey);
-}
-
-export interface SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey extends QueryKey>
-    extends SyncedOptions<TData> {
-    queryClient: QueryClient;
-    query: ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey>;
-    mutation?: MutationObserverOptions<TData, TError, void>;
-}
-
-export function syncedQuery<
-    TQueryFnData = unknown,
-    TError = DefaultError,
-    TData = TQueryFnData,
-    TQueryKey extends QueryKey = QueryKey,
->(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>) {
-    const { query: options, mutation: mutationOptions, queryClient } = params;
-
-    const Observer = QueryObserver;
-    const defaultedOptions = queryClient!.defaultQueryOptions(
-        options as QueryObserverOptions<TQueryFnData, TError, TData, TQueryKey>,
-    );
-    let observer: QueryObserver<TQueryFnData, TError, TData, TQueryKey> | undefined = undefined;
-    let latestOptions = defaultedOptions;
-    let queryKeyFromFn: TQueryKey;
-
-    const origQueryKey = options.queryKey!;
-
-    // If the queryKey is a function, observe it and extract the raw value
-    const isKeyFunction = isFunction(origQueryKey);
-
-    const updateQueryOptions = (obj: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey>) => {
-        // Since legend-state mutates the query options, we need to clone it to make Query
-        // see it as changed
-        const options = Object.assign({}, obj);
-
-        // Use the latest value from the observed queryKey function
-        if (isKeyFunction) {
-            options.queryKey = queryKeyFromFn;
-        }
-
-        latestOptions = options;
-
-        // Update the Query options
-        if (observer) {
-            observer.setOptions(options, { listeners: false });
-        }
-    };
-
-    if (isKeyFunction) {
-        observe(() => {
-            queryKeyFromFn = origQueryKey();
-            updateQueryOptions(latestOptions);
-        });
-    }
-
-    // Create the observer
-    observer = new Observer!<TQueryFnData, TError, TData, TQueryKey>(queryClient!, latestOptions);
-
-    const get = () => {
-        // Get the initial optimistic results if it's already cached
-        const result = observer!.getOptimisticResult(latestOptions);
-
-        return result.data!;
-    };
-
-    const subscribe = ({ update }: SyncedSubscribeParams<TData>) => {
-        // Subscribe to Query's observer and update the observable
-        const unsubscribe = observer!.subscribe(
-            notifyManager.batchCalls((result) => {
-                if (result.status === 'success') {
-                    update({ value: result.data });
-                }
-            }),
-        );
-
-        // Update result to make sure we did not miss any query updates
-        // between creating the observer and subscribing to it.
-        observer.updateResult();
-
-        return unsubscribe;
-    };
-
-    let set: undefined | (({ value }: SyncedSetParams<TData>) => Promise<TData>) = undefined;
-    if (mutationOptions) {
-        const mutator = new MutationObserver(queryClient!, mutationOptions);
-        set = ({ value }: SyncedSetParams<TData>) => {
-            return mutator.mutate(value as any);
-        };
-    }
-
-    return synced({
-        get,
-        set,
-        subscribe,
-    });
-}

package/src/sync-plugins/tanstack-react-query.ts

@@ -1,12 +0,0 @@
-import { useObservable } from '@legendapp/state/react';
-import { SyncedQueryParams, syncedQuery } from '@legendapp/state/sync-plugins/tanstack-query';
-import { DefaultError, QueryKey } from '@tanstack/query-core';
-
-export function useObservableSyncedQuery<
-    TQueryFnData = unknown,
-    TError = DefaultError,
-    TData = TQueryFnData,
-    TQueryKey extends QueryKey = QueryKey,
->(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>) {
-    return useObservable(syncedQuery(params));
-}

package/src/trace/traceHelpers.ts

@@ -1,11 +0,0 @@
-import type { NodeValue } from '@legendapp/state';
-
-export function getNodePath(node: NodeValue) {
-    const arr: (string | number)[] = [];
-    let n = node;
-    while (n?.key !== undefined) {
-        arr.splice(0, 0, n.key);
-        n = n.parent;
-    }
-    return arr.join('.');
-}

package/src/trace/useTraceListeners.ts

@@ -1,34 +0,0 @@
-import { NodeValue, internal, TrackingNode } from '@legendapp/state';
-import { getNodePath } from './traceHelpers';
-const { optimized, tracking } = internal;
-
-export function useTraceListeners(this: any, name?: string) {
-    if (process.env.NODE_ENV === 'development' && tracking.current) {
-        tracking.current.traceListeners = traceNodes.bind(this, name);
-    }
-}
-
-function traceNodes(name: string | undefined, nodes: Map<NodeValue, TrackingNode>) {
-    if (process.env.NODE_ENV === 'development' && tracking.current) {
-        tracking.current.traceListeners = undefined;
-        const arr: string[] = [];
-        if (nodes) {
-            for (const tracked of nodes.values()) {
-                const { node, track } = tracked;
-                const shallow = track === true;
-                const isOptimized = track === optimized;
-                arr.push(
-                    `${arr.length + 1}: ${getNodePath(node)}${shallow ? ' (shallow)' : ''}${
-                        isOptimized ? ' (optimized)' : ''
-                    }`,
-                );
-            }
-        }
-
-        console.log(
-            `[legend-state] ${name ? name + ' ' : ''}tracking ${arr.length} observable${
-                arr.length !== 1 ? 's' : ''
-            }:\n${arr.join('\n')}`,
-        );
-    }
-}

package/src/trace/useTraceUpdates.ts

@@ -1,24 +0,0 @@
-import { ListenerParams, internal } from '@legendapp/state';
-const { tracking } = internal;
-
-export function useTraceUpdates(name?: string) {
-    if (process.env.NODE_ENV === 'development' && tracking.current) {
-        tracking.current.traceUpdates = replaceUpdateFn.bind(undefined, name);
-    }
-}
-
-function replaceUpdateFn(name: string | undefined, updateFn: Function) {
-    return onChange.bind(undefined, name, updateFn);
-}
-
-function onChange(name: string | undefined, updateFn: Function, params: ListenerParams<any>) {
-    const { changes } = params;
-    if (process.env.NODE_ENV === 'development') {
-        changes.forEach(({ path, valueAtPath, prevAtPath }) => {
-            console.log(`[legend-state] Rendering ${name ? name + ' ' : ''}because "${path}" changed:
-from: ${JSON.stringify(prevAtPath)}
-to: ${JSON.stringify(valueAtPath)}`);
-        });
-        return updateFn();
-    }
-}

package/src/trace/useVerifyNotTracking.ts

@@ -1,33 +0,0 @@
-import { internal, NodeValue, TrackingNode } from '@legendapp/state';
-import { getNodePath } from './traceHelpers';
-const { optimized, tracking } = internal;
-
-export function useVerifyNotTracking(this: any, name?: string) {
-    if (process.env.NODE_ENV === 'development') {
-        tracking.current!.traceListeners = traceNodes.bind(this, name);
-    }
-}
-
-function traceNodes(name: string | undefined, nodes: Map<NodeValue, TrackingNode>) {
-    if (process.env.NODE_ENV === 'development') {
-        tracking.current!.traceListeners = undefined;
-        const arr: string[] = [];
-        if (nodes) {
-            for (const tracked of nodes.values()) {
-                const { node, track } = tracked;
-                const shallow = track === true;
-                const isOptimized = track === optimized;
-                arr.push(
-                    `${arr.length + 1}: ${getNodePath(node)}${shallow ? ' (shallow)' : ''}${
-                        isOptimized ? ' (optimized)' : ''
-                    }`,
-                );
-            }
-            console.error(
-                `[legend-state] ${name ? name + ' ' : ''}tracking ${arr.length} observable${
-                    arr.length !== 1 ? 's' : ''
-                } when it should not be:\n${arr.join('\n')}`,
-            );
-        }
-    }
-}

package/src/trace/useVerifyOneRender.ts

@@ -1,10 +0,0 @@
-import { useRef } from 'react';
-
-export function useVerifyOneRender(name?: string) {
-    if (process.env.NODE_ENV === 'development') {
-        const numRenders = ++useRef(0).current;
-        if (numRenders > 1) {
-            console.error(`[legend-state] ${name ? name + ' ' : ''}Component rendered more than once`);
-        }
-    }
-}

package/src/trackSelector.ts

@@ -1,52 +0,0 @@
-import { computeSelector } from './helpers';
-import type { ListenerParams, ObserveEvent, Selector } from './observableInterfaces';
-import type { ObserveOptions } from './observe';
-import { setupTracking } from './setupTracking';
-import { beginTracking, endTracking, tracking } from './tracking';
-
-export function trackSelector<T>(
-    selector: Selector<T>,
-    update: (params: ListenerParams) => void,
-    observeEvent?: ObserveEvent<T>,
-    observeOptions?: ObserveOptions,
-    createResubscribe?: boolean,
-) {
-    let dispose: undefined | (() => void);
-    let resubscribe: (() => () => void) | undefined;
-    let updateFn = update;
-
-    beginTracking();
-    const value = selector ? computeSelector(selector, observeEvent, observeOptions?.fromComputed) : selector;
-    const tracker = tracking.current;
-    const nodes = tracker!.nodes;
-    endTracking();
-
-    if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') && tracker && nodes) {
-        tracker.traceListeners?.(nodes);
-        if (tracker.traceUpdates) {
-            updateFn = tracker.traceUpdates(update) as () => void;
-        }
-        // Clear tracing so it doesn't leak to other components
-        tracker.traceListeners = undefined;
-        tracker.traceUpdates = undefined;
-    }
-
-    if (!observeEvent?.cancel) {
-        // Do tracing if it was requested
-
-        // useSyncExternalStore doesn't subscribe until after the component mount.
-        // We want to subscribe immediately so we don't miss any updates
-        dispose = setupTracking(nodes, updateFn, false, observeOptions?.immediate);
-        if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
-            resubscribe = createResubscribe
-                ? () => {
-                      dispose?.();
-                      dispose = setupTracking(nodes, updateFn);
-                      return dispose;
-                  }
-                : undefined;
-        }
-    }
-
-    return { nodes, value, dispose, resubscribe };
-}

package/src/tracking.ts

@@ -1,43 +0,0 @@
-import type { NodeValue, TrackingState, TrackingType } from './observableInterfaces';
-
-let trackCount = 0;
-const trackingQueue: (TrackingState | undefined)[] = [];
-
-export const tracking = {
-    current: undefined as TrackingState | undefined,
-};
-
-export function beginTracking() {
-    // Keep a copy of the previous tracking context so it can be restored
-    // when this context is complete
-    trackingQueue.push(tracking.current);
-    trackCount++;
-    tracking.current = {};
-}
-export function endTracking() {
-    // Restore the previous tracking context
-    trackCount--;
-    if (trackCount < 0) {
-        trackCount = 0;
-    }
-    tracking.current = trackingQueue.pop();
-}
-
-export function updateTracking(node: NodeValue, track?: TrackingType) {
-    if (trackCount) {
-        const tracker = tracking.current;
-        if (tracker) {
-            if (!tracker.nodes) {
-                tracker.nodes = new Map();
-            }
-
-            const existing = tracker.nodes.get(node);
-            if (existing) {
-                existing.track = existing.track || track;
-                existing.num++;
-            } else {
-                tracker.nodes.set(node, { node, track, num: 1 });
-            }
-        }
-    }
-}

package/src/types/babel.d.ts

@@ -1,12 +0,0 @@
-import type { ObservableParam } from '@legendapp/state';
-import { ReactNode } from 'react';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import type { Computed, Memo } from '@legendapp/state/react';
-declare module '@legendapp/state/react' {
-    export declare const Computed: (props: {
-        children: ObservableParam | (() => ReactNode) | ReactNode;
-    }) => React.ReactElement;
-    export declare const Memo: (props: {
-        children: ObservableParam | (() => ReactNode) | ReactNode;
-    }) => React.ReactElement;
-}

package/src/when.ts

@@ -1,75 +0,0 @@
-import { computeSelector, isObservableValueReady } from './helpers';
-import { isPromise } from './is';
-import type { ObserveEvent, Selector } from './observableInterfaces';
-import { observe } from './observe';
-
-function _when<T, T2>(predicate: Selector<T>, effect?: (value: T) => T2, checkReady?: boolean): any {
-    // If predicate is a regular Promise skip all the observable stuff
-    if (isPromise<T>(predicate)) {
-        return effect ? predicate.then(effect) : (predicate as any);
-    }
-
-    let value: T | undefined;
-    let effectValue: T2 | undefined;
-
-    // Create a wrapping fn that calls the effect if predicate returns true
-    function run(e: ObserveEvent<T>) {
-        const ret = computeSelector(predicate);
-
-        if (isPromise(ret)) {
-            value = ret as any;
-            // We want value to be the Promise but return undefined
-            // so it doesn't run the effect with the Promise as the value
-            return undefined;
-        } else if (!isPromise(ret) && (checkReady ? isObservableValueReady(ret) : ret)) {
-            value = ret;
-
-            // Set cancel so that observe does not track anymore
-            e.cancel = true;
-        }
-
-        return value;
-    }
-    function doEffect() {
-        // If value is truthy then run the effect
-        effectValue = effect?.(value!);
-    }
-    // Run in an observe
-    observe(run, doEffect);
-
-    // If first run resulted in a truthy value just return it.
-    // It will have set e.cancel so no need to dispose
-    if (isPromise<T>(value)) {
-        return effect ? value.then(effect) : (value as any);
-    } else if (value !== undefined) {
-        return effect ? effectValue : Promise.resolve(value);
-    } else {
-        // Wrap it in a promise
-        const promise = new Promise<T2>((resolve) => {
-            if (effect) {
-                const originalEffect = effect;
-                effect = ((value: T) => {
-                    const effectValue = originalEffect(value);
-                    resolve(isPromise(effectValue) ? effectValue.then((value) => value as T2) : effectValue);
-                }) as any;
-            } else {
-                effect = resolve as any;
-            }
-        });
-
-        return promise;
-    }
-}
-
-export function when<T, T2>(predicate: Promise<T>, effect: (value: T) => T2): Promise<T2>;
-export function when<T, T2>(predicate: Selector<T>, effect: (value: T) => T2): Promise<T2>;
-export function when<T>(predicate: Selector<T>): Promise<T>;
-export function when<T, T2>(predicate: Selector<T>, effect?: (value: T) => T2): Promise<T | T2> {
-    return _when<T, T2>(predicate, effect, false);
-}
-export function whenReady<T, T2>(predicate: Promise<T>, effect: (value: T) => T2): Promise<T2>;
-export function whenReady<T, T2>(predicate: Selector<T>, effect: (value: T) => T2): Promise<T2>;
-export function whenReady<T>(predicate: Selector<T>): Promise<T>;
-export function whenReady<T, T2>(predicate: Selector<T>, effect?: (value: T) => T2): Promise<T | T2> {
-    return _when<T, T2>(predicate, effect, true);
-}