@ispb/react-lazy 0.0.4 → 0.0.6

package/src/observable.tsx

@@ -1,83 +0,0 @@
-
-import { ReactNode, useEffect, useState } from "react"
-import { Observable, ObservedValueOf } from "rxjs"
-import { Lazy } from "./components.js"
-import { LazyHOCOptions, lazified } from "./hoc.js"
-import { useLazyFlatten } from "./hooks.js"
-import { useIsFirstMount } from "./internal.js"
-import { LazyState } from "./state.js"
-import { LazyEvent, LazyOverrides } from "./types.js"
-
-export type ObservableLazyInput = Observable<any>// | Record<string, ObservableInput<any>>
-export type ObservableLazyOutput<X extends ObservableLazyInput> = X extends Observable<any> ? ObservedValueOf<X> : { [K in keyof X]: ObservedValueOf<X[K]> }
-
-export interface ObservableLazyOptions<D> {
-
-    readonly of: Observable<D>
-
-}
-
-export function useObservableLazyWrapped<D>(options: ObservableLazyOptions<LazyEvent<D>>) {
-    return useLazyFlatten(useObservableLazy(options))
-}
-
-export function useObservableLazy<D>(options: ObservableLazyOptions<D>) {
-    const [event, setEvent] = useState<LazyEvent<D>>({ status: "loading" as const })
-    const isFirstMount = useIsFirstMount()
-    useEffect(() => {
-        if (!isFirstMount) {
-            setEvent({
-                status: "loading"
-            })
-        }
-        const sub = options.of.subscribe({
-            next: value => {
-                setEvent({
-                    status: "fulfilled",
-                    value
-                })
-            },
-            error: reason => {
-                setEvent({
-                    status: "rejected",
-                    reason
-                })
-            }
-        })
-        return () => {
-            sub.unsubscribe()
-        }
-    }, [
-        options.of
-    ])
-    return event
-}
-
-export interface ObservingOptions<D, P> extends ObservableLazyOptions<D>, LazyHOCOptions<LazyState<D>, P> {
-}
-
-export function observing<I extends {}, D extends {}, P extends {}>(factory: (props: I) => ObservingOptions<D, P>) {
-    return lazified((props: I) => {
-        const options = factory(props)
-        const event = useObservableLazy(options)
-        return {
-            event,
-            passthrough: options.passthrough,
-            overrides: options.overrides,
-        }
-    })
-}
-
-export interface ObservingProps<D> extends ObservableLazyOptions<D> {
-
-    readonly children: (value: D, state: LazyState<D>) => ReactNode
-    readonly overrides?: LazyOverrides | undefined
-
-}
-
-export const Observing = <D,>(props: ObservingProps<D>) => {
-    const event = useObservableLazy(props)
-    return <Lazy event={event}
-        overrides={props.overrides}
-        children={props.children} />
-}

package/src/types.tsx

@@ -1,75 +0,0 @@
-import { ReactNode } from "react"
-
-export type LazyLoading = { readonly status: "loading" }
-export type LazyFulfilled<D> = { readonly status: "fulfilled", readonly value: D }
-export type LazyRejected = { readonly status: "rejected", readonly reason: unknown, readonly retry?: (() => void) | undefined }
-export type LazySettled<D> = LazyFulfilled<D> | LazyRejected
-export type LazyEvent<D> = LazySettled<D> | LazyLoading
-
-export type OnLoading = (props: LoadingProps) => ReactNode
-export type OnReloading = (props: ReloadingProps) => ReactNode
-export type OnError = (props: ErrorProps) => ReactNode
-
-type LazyMeta = string
-
-export interface LoadingProps {
-
-    /**
-     * The message to display.
-     */
-    readonly message?: LazyMeta | undefined
-
-}
-
-export interface ReloadingProps {
-
-    /**
-     * Whether or not the data is currently reloading.
-     */
-    readonly reloading: boolean
-
-    /**
-     * The message to display.
-     */
-    readonly message?: LazyMeta | undefined
-
-    /**
-     * The children.
-     */
-    readonly children: ReactNode
-
-}
-
-export interface ErrorProps {
-
-    /**
-     * The error.
-     */
-    readonly reason: unknown
-
-    /**
-     * The message to display.
-     */
-    readonly message?: LazyMeta | undefined
-
-}
-
-export interface LazyOptions {
-
-    readonly onLoading?: OnLoading | undefined
-    readonly onReloading?: OnReloading | undefined
-    readonly onError?: OnError | undefined
-
-    readonly defaultMessage?: LazyMeta | undefined
-    readonly loadingMessage?: LazyMeta | undefined
-    readonly reloadingMessage?: LazyMeta | undefined
-    readonly errorMessage?: LazyMeta | undefined
-
-}
-
-/**
- * Overrides for lazy options.
- */
-export type LazyOverrides = Partial<LazyOptions>
-
-export type ExtractLazy<T> = T extends LazyFulfilled<infer D> ? D : never

package/tsconfig.json

@@ -1,27 +0,0 @@
-{
-    "compilerOptions": {
-        "jsx": "react-jsx",
-        "strict": true,
-        "alwaysStrict": true,
-        "allowUnreachableCode": false,
-        "allowUnusedLabels": false,
-        "noImplicitAny": true,
-        "noImplicitThis": true,
-        "noImplicitOverride": true,
-        "noUnusedLocals": true,
-        "noUnusedParameters": true,
-        "noPropertyAccessFromIndexSignature": true,
-        "noUncheckedIndexedAccess": true,
-        "noFallthroughCasesInSwitch": true,
-        "useUnknownInCatchVariables": true,
-        "exactOptionalPropertyTypes": true,
-        "moduleResolution": "nodenext",
-        "module": "nodenext",
-        "target": "esnext",
-        "declaration": true,
-        "sourceMap": true,
-        "skipLibCheck": true,
-        "rootDir": "src",
-        "outDir": "dist"
-    }
-}