unwrapped 0.1.1 → 0.1.3

package/src/core/result.ts

@@ -1,101 +0,0 @@
-import { ErrorBase } from "./error";
-
-export type ResultState<T, E = ErrorBase> =
-  | { status: 'success'; value: T }
-  | { status: 'error'; error: E };
-
-
-export class Result<T, E = ErrorBase> {
-  private _state: ResultState<T, E>;
-
-  constructor(state: ResultState<T, E>) {
-    this._state = state;
-  }
-
-  get state() {
-    return this._state;
-  }
-
-  static ok<T, E = ErrorBase>(value: T): Result<T, E> {
-    return new Result({ status: 'success', value });
-  }
-
-  static err<E>(error: E): Result<never, E> {
-    return new Result({ status: 'error', error });
-  }
-
-  static errTag(code: string, message?: string): Result<never, ErrorBase> {
-    return Result.err(new ErrorBase(code, message));
-  }
-
-  unwrapOrNull(): T | null {
-    if (this._state.status === 'success') {
-      return this._state.value;
-    }
-    return null;
-  }
-
-  unwrapOrThrow(): T {
-    if (this._state.status === 'success') {
-      return this._state.value;
-    }
-    throw new Error('Tried to unwrap a Result that is not successful');
-  }
-
-  unwrapOr<O>(defaultValue: O): T | O {
-    if (this._state.status === 'success') {
-      return this._state.value;
-    }
-    return defaultValue;
-  }
-
-  isSuccess(): boolean {
-    return this._state.status === 'success';
-  }
-
-  isError(): boolean {
-    return this._state.status === 'error';
-  }
-
-  static tryPromise<T, E>(promise: Promise<T>, errorMapper: (error: unknown) => E): Promise<Result<T, E>> {
-    return promise
-      .then((value) => Result.ok<T, E>(value))
-      .catch((error) => Result.err(errorMapper(error)));
-  }
-
-  static tryFunction<T, E extends ErrorBase = ErrorBase>(fn: () => Promise<T>, errorMapper: (error: unknown) => E): Promise<Result<T, E>> {
-    return Result.tryPromise(fn(), errorMapper);
-  }
-
-  chain<O, E2>(fn: (input: T) => ResultState<O, E | E2>): Result<O, E | E2> {
-    if (this._state.status === 'success') {
-      return new Result<O, E | E2>(fn(this._state.value));
-    }
-    return Result.err<E>(this._state.error);
-  }
-
-  *[Symbol.iterator](): Generator<Result<T, E>, T, any> {
-    yield this;
-
-    if (this._state.status === 'success') {
-      return this._state.value;
-    }
-    return undefined as T;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static run<T, E>(generator: () => Generator<Result<any, E>, T, any>): Result<T, E> {
-    const iterator = generator();
-    let result = iterator.next();
-
-    while (!result.done) {
-      const yielded = result.value;
-      if (yielded._state.status === 'error') {
-        return Result.err(yielded._state.error);
-      }
-      result = iterator.next(yielded._state.value);
-    }
-
-    return Result.ok(result.value);
-  }
-}

package/src/vue/components/asyncResultLoader.ts

@@ -1,99 +0,0 @@
-import { defineComponent, ref, watch, onUnmounted, h, type VNode } from "vue"
-import type { AsyncResult, AsyncResultState } from "unwrapped/core"
-
-export const AsyncResultLoader = defineComponent({
-    name: "AsyncResultLoader",
-
-    props: {
-        result: {
-            type: Object as () => AsyncResult<unknown, unknown>,
-            required: true
-        }
-    },
-
-    setup(props, { slots }) {
-        const state = ref<AsyncResultState<unknown, unknown>>(props.result.state)
-        let unlisten: (() => void) | null = null
-
-        // Unsubscribe on destroy
-        onUnmounted(() => {
-            if (unlisten) unlisten()
-        })
-
-        // Watch for prop changes & update listener
-        watch(
-            () => props.result,
-            (newResult) => {
-                if (unlisten) unlisten()
-                state.value = newResult.state
-                unlisten = newResult.listen((res) => {
-                    state.value = res.state
-                })
-            },
-            { immediate: true }
-        )
-
-        return () => {
-            const s = state.value
-
-            // Choose what to render based on status
-            switch (s.status) {
-                case "loading":
-                    return slots.loading
-                        ? slots.loading()
-                        : h("div", { class: "loading" }, "Loading…")
-
-                case "error":
-                    return slots.error
-                        ? slots.error({ error: s.error })
-                        : h("div", { class: "error" }, `Error: ${s.error}`)
-
-                case "success":
-                    return slots.default
-                        ? slots.default({ value: s.value })
-                        : null
-
-                default:
-                    // "idle"
-                    return slots.idle
-                        ? slots.idle()
-                        : h("div", { class: "idle" }, "Idle")
-            }
-        }
-    }
-})
-
-interface CustomSlots<E> {
-    loading?: () => VNode;
-    error?: (props: { error: E }) => VNode;
-}
-
-export function buildCustomAsyncResultLoader<T, E>(slots: CustomSlots<E>) {
-    const comp = defineComponent({
-        name: "CustomAsyncResultLoader",
-        props: {
-            result: {
-                type: Object as () => AsyncResult<T, E>,
-                required: true
-            }
-        },
-        setup(props, context) {
-            return () => {
-                const renderLoading = context.slots.loading ?? slots.loading ?? (() => undefined);
-                const renderError = context.slots.error ?? slots.error ?? (() => undefined);
-                return h(
-                    AsyncResultLoader,
-                    { result: props.result },
-                    {
-                        default: context.slots.default ? (propsDefault: { value: T }) => context.slots.default!(propsDefault) : undefined,
-
-                        loading: () => renderLoading(),
-                        error: ((propsError: { error: E }) => renderError(propsError))
-                    }
-                )
-            }
-        }
-    });
-
-    return comp;
-}

package/src/vue/composables.ts

@@ -1,106 +0,0 @@
-import { computed, onUnmounted, ref, toRef, triggerRef, watch, type Ref, type WatchSource } from "vue";
-import { AsyncResult, type FlatChainFunction, type Result } from "unwrapped/core";
-
-export function useAsyncResultRef<T, E>(asyncResult: AsyncResult<T, E>) {
-  const state = ref<AsyncResult<T, E>>(asyncResult) as Ref<AsyncResult<T, E>>;
-
-  const unsub = asyncResult.listen(() => {
-    triggerRef(state);
-  });
-
-  onUnmounted(() => {
-    unsub();
-  });
-
-  return state;
-}
-
-export function useReactiveResult<T, E, Inputs>(source: WatchSource<Inputs>, pipe: FlatChainFunction<Inputs, T, E>, options:{ immediate: boolean } = { immediate: true }): Ref<AsyncResult<T, E>> {
-  const result = new AsyncResult<T, E>();
-  const resultRef = useAsyncResultRef(result);
-
-  let unsub: (() => void) | null = null;
-
-  watch(source, (newInputs) => {
-    unsub?.();
-    unsub = result.mirror(pipe(newInputs));
-  }, { immediate: options.immediate });
-  
-  onUnmounted(() => {
-    unsub?.();
-  });
-
-  return resultRef;
-}
-
-export function useAsyncResultRefFromPromise<T, E>(promise: Promise<Result<T, E>>) {
-  return useAsyncResultRef(AsyncResult.fromResultPromise(promise));
-}
-
-export type Action<T,E> = () => Promise<Result<T, E>>;
-export function useImmediateAction<T, E>(action: Action<T, E>): Ref<AsyncResult<T, E>> {
-  return useAsyncResultRefFromPromise(action());
-}
-export interface LazyActionReturn<T, E> {
-  resultRef: Ref<AsyncResult<T, E>>;
-  trigger: () => void;
-}
-
-export function useLazyAction<T, E>(action: Action<T, E>): LazyActionReturn<T, E> {
-  const result = new AsyncResult<T, E>();
-  const resultRef = useAsyncResultRef(result);
-
-  const trigger = () => {
-    result.updateFromResultPromise(action());
-  }
-
-  return { resultRef, trigger };
-}
-
-export function useReactiveAction<I, O, E>(input: I | Ref<I> | (() => I), pipe: FlatChainFunction<I, O, E>, options:{ immediate: boolean } = { immediate: true }): Ref<AsyncResult<O, E>> {
-  const source = typeof input === 'function' ? computed(input as () => I) : toRef(input)
-
-  const outputRef = ref<AsyncResult<O, E>>(new AsyncResult()) as Ref<AsyncResult<O, E>>;
-  let unsub: (() => void) | null = null;
-
-  watch(source, () => {
-    unsub?.();
-    const newOutput = pipe(source.value);
-    unsub = newOutput.listen((newState) => {
-      outputRef.value.setState(newState.state);
-      triggerRef(outputRef);
-    });
-  }, { immediate: options.immediate });
-
-  onUnmounted(() => {
-    unsub?.();
-  });
-
-  return outputRef;
-}
-
-export function useGenerator<T>(generatorFunc: () => Generator<AsyncResult<any, any>, T, any>): Ref<AsyncResult<T, any>> {
-  const resultRef = useAsyncResultRef(AsyncResult.run(generatorFunc));
-  return resultRef;
-}
-
-export function useLazyGenerator<T>(generatorFunc: () => Generator<AsyncResult<any, any>, T, any>): { resultRef: Ref<AsyncResult<T, any>>, trigger: () => void } {
-  const result = new AsyncResult<T, any>();
-  const resultRef = useAsyncResultRef(result);
-
-  const trigger = () => {
-    result.runInPlace(generatorFunc);
-  }
-
-  return { resultRef, trigger };
-}
-
-export function useReactiveGenerator<T, E, Inputs>(source: WatchSource<Inputs>, generatorFunc: (args: Inputs) => Generator<AsyncResult<any, any>, T, any>, options:{ immediate: boolean } = { immediate: true }): Ref<AsyncResult<T, E>> {
-  const resultRef = useAsyncResultRef(new AsyncResult<T, E>());
-
-  watch(source, (newInputs) => {
-    resultRef.value.runInPlace(() => generatorFunc(newInputs));
-  }, { immediate: options.immediate });
-
-  return resultRef;
-}

package/src/vue/index.ts

@@ -1,2 +0,0 @@
-export * from "./composables"
-export * from "./components/asyncResultLoader"