floppy-disk 2.16.0 → 3.0.0-alpha.2

package/vanilla.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const isClient = typeof window !== "undefined" && !("Deno" in window);
+const noop = () => {
+};
+const identity = (value) => value;
+const getValue = (valueOrComputeValueFn, ...params) => {
+  if (typeof valueOrComputeValueFn === "function") {
+    return valueOrComputeValueFn(...params);
+  }
+  return valueOrComputeValueFn;
+};
+
+const shallow = (a, b) => {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [key, value] of a) {
+      if (!Object.is(value, b.get(key))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const value of a) {
+      if (!b.has(value)) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  if (keysA.length !== Object.keys(b).length) {
+    return false;
+  }
+  for (let i = 0; i < keysA.length; i++) {
+    if (!Object.prototype.hasOwnProperty.call(b, keysA[i]) || !Object.is(a[keysA[i]], b[keysA[i]])) {
+      return false;
+    }
+  }
+  return true;
+};
+
+const hasObjectPrototype = (value) => {
+  return Object.prototype.toString.call(value) === "[object Object]";
+};
+const isPlainObject = (value) => {
+  if (!hasObjectPrototype(value)) return false;
+  const ctor = value.constructor;
+  if (typeof ctor === "undefined") return true;
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot)) return false;
+  if (!prot.hasOwnProperty("isPrototypeOf")) return false;
+  if (Object.getPrototypeOf(value) !== Object.prototype) return false;
+  return true;
+};
+const getHash = (value) => JSON.stringify(
+  value,
+  (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+    result[key] = val[key];
+    return result;
+  }, {}) : val
+);
+
+const initStore = (initialState, options = {}) => {
+  const {
+    onFirstSubscribe = noop,
+    onSubscribe = noop,
+    onUnsubscribe = noop,
+    onLastUnsubscribe = noop
+  } = options;
+  const subscribers = /* @__PURE__ */ new Set();
+  const getSubscribers = () => subscribers;
+  const subscribe = (subscriber) => {
+    subscribers.add(subscriber);
+    if (subscribers.size === 1) onFirstSubscribe(state, storeApi);
+    onSubscribe(state, storeApi);
+    return () => {
+      subscribers.delete(subscriber);
+      onUnsubscribe(state, storeApi);
+      if (subscribers.size === 0) onLastUnsubscribe(state, storeApi);
+    };
+  };
+  let state = initialState;
+  const getState = () => state;
+  const setState = (value) => {
+    const prevState = state;
+    const newValue = getValue(value, state);
+    for (const key in newValue) {
+      if (!Object.is(prevState[key], newValue[key])) {
+        state = { ...prevState, ...newValue };
+        [...subscribers].forEach((subscriber) => subscriber(state, prevState));
+        return;
+      }
+    }
+  };
+  const storeApi = {
+    getState,
+    setState,
+    subscribe,
+    getSubscribers
+  };
+  return storeApi;
+};
+
+exports.getHash = getHash;
+exports.getValue = getValue;
+exports.identity = identity;
+exports.initStore = initStore;
+exports.isClient = isClient;
+exports.isPlainObject = isPlainObject;
+exports.noop = noop;
+exports.shallow = shallow;

package/esm/fetcher.d.ts

@@ -1,27 +0,0 @@
-type FetcherOptions<TResponse = any> = {
-    url: string;
-    query?: string;
-    params?: Record<string, string | number | boolean> | null;
-    payload?: any;
-    interceptRequest?: (requestOptions: RequestInit & {
-        url: string;
-    }) => (RequestInit & {
-        url: string;
-    }) | Promise<RequestInit & {
-        url: string;
-    }>;
-    interceptResponse?: (response: TResponse) => TResponse | Promise<TResponse>;
-} & RequestInit;
-/**
- * Experimental fetcher - abstraction layer for query/mutation function creator.
- *
- * Can be used for REST or GraphQL.
- *
- * Only work for JSON response only.
- *
- * @see https://floppy-disk.vercel.app/docs/experimental
- *
- * @returns A function to fetch data
- */
-export declare const fetcher: <TResponse = any, TInput extends any[] = any[]>(options: FetcherOptions<TResponse> | ((...args: TInput) => FetcherOptions<TResponse>)) => (...args: TInput) => Promise<TResponse>;
-export {};

package/esm/fetcher.js

@@ -1,95 +0,0 @@
-import { createError, getValue, identityFn } from './utils';
-const encodeParams = (params) => Object.entries(params)
-    .filter(([, value]) => value !== undefined && value !== null)
-    .map((kv) => kv.map(encodeURIComponent).join('='))
-    .join('&');
-/**
- * Experimental fetcher - abstraction layer for query/mutation function creator.
- *
- * Can be used for REST or GraphQL.
- *
- * Only work for JSON response only.
- *
- * @see https://floppy-disk.vercel.app/docs/experimental
- *
- * @returns A function to fetch data
- */
-export const fetcher = (options) => async (...args) => {
-    const { url, query, params, payload, headers, interceptRequest = identityFn, interceptResponse, ...rest } = getValue(options, ...args);
-    let autoOptions = {};
-    let searchParams = params;
-    if (query) {
-        // GraphQL
-        autoOptions = {
-            method: 'POST',
-            body: JSON.stringify({ query, variables: payload || args[0] }),
-        };
-    }
-    else if (rest.method && rest.method.toLowerCase() !== 'get') {
-        // REST - Mutation
-        autoOptions = {
-            body: JSON.stringify(payload === undefined ? args[0] : payload),
-        };
-    }
-    else {
-        // REST - Query
-        if (typeof options === 'object' && params === undefined)
-            searchParams = args[0];
-    }
-    const interceptedOptions = await interceptRequest({
-        url: searchParams ? [url, encodeParams(searchParams)].join('?') : url,
-        headers: { 'Content-Type': 'application/json', ...headers },
-        ...autoOptions,
-        ...rest,
-    });
-    const { url: finalUrl, ...finalOptions } = interceptedOptions;
-    const res = await fetch(finalUrl, finalOptions);
-    const contentType = res.headers.get('content-type');
-    const isJsonFile = /\.json(\?.+)?$/.test(finalUrl);
-    if (contentType?.includes('application/json') || isJsonFile) {
-        let resJson = await res.json();
-        if (query) {
-            if (resJson.errors) {
-                throw createError('Error GraphQL response', {
-                    status: res.status,
-                    statusText: res.statusText,
-                    response: resJson.errors,
-                    request: interceptedOptions,
-                });
-            }
-            resJson = resJson.data;
-        }
-        if (res.ok) {
-            if (interceptResponse) {
-                try {
-                    const finalResponse = await interceptResponse(resJson);
-                    return finalResponse;
-                }
-                catch (error) {
-                    throw createError('Error intercept response', {
-                        status: res.status,
-                        statusText: res.statusText,
-                        response: resJson,
-                        error,
-                        request: interceptedOptions,
-                    });
-                }
-            }
-            return resJson;
-        }
-        throw createError('Fetch error', {
-            status: res.status,
-            statusText: res.statusText,
-            response: resJson,
-            request: interceptedOptions,
-        });
-    }
-    const resText = await res.text().catch(() => undefined);
-    throw createError('Response type is not a JSON', {
-        status: res.status,
-        statusText: res.statusText,
-        response: resText,
-        contentType,
-        request: interceptedOptions,
-    });
-};

package/esm/index.d.ts

@@ -1,8 +0,0 @@
-export * from './store';
-export * from './fetcher';
-export * from './react/create-store';
-export * from './react/create-stores';
-export * from './react/create-query';
-export * from './react/create-bi-direction-query';
-export * from './react/create-mutation';
-export * from './react/with-context';

package/esm/index.js

@@ -1,8 +0,0 @@
-export * from './store';
-export * from './fetcher';
-export * from './react/create-store';
-export * from './react/create-stores';
-export * from './react/create-query';
-export * from './react/create-bi-direction-query';
-export * from './react/create-mutation';
-export * from './react/with-context';

package/esm/react/create-bi-direction-query.d.ts

@@ -1,166 +0,0 @@
-import { Maybe } from '../utils';
-import { CreateQueryOptions, QueryState } from './create-query';
-import { StoreKey } from './create-stores';
-export declare const createBiDirectionQuery: <TKey extends StoreKey = StoreKey, TResponse = any, TData extends any[] = any[], TError = unknown, TPageParam = any>(queryFn: (key: TKey, state: QueryState<TKey, TResponse, TData, TError, TPageParam>, direction: 'prev' | 'next') => Promise<TResponse>, options: Omit<CreateQueryOptions<TKey, TResponse, TData, TError, TPageParam>, "select" | "getNextPageParam"> & {
-    getPrevPageParam: (lastPage: TResponse, index: number, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError, TPageParam>) => Maybe<TPageParam>;
-    getNextPageParam: (lastPage: TResponse, index: number, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError, TPageParam>) => Maybe<TPageParam>;
-    select: (response: TResponse, state: Pick<QueryState<TKey, TResponse, TData, TError, TPageParam>, "data" | "key">, direction: 'prev' | 'next') => TData;
-}) => {
-    (key: Maybe<TKey>, selectDeps?: "data" | "key" | "error" | "reset" | "status" | "fetch" | "response" | "keyHash" | "forceFetch" | "fetchNextPage" | "optimisticUpdate" | "isWaiting" | "isWaitingNextPage" | "isRefetching" | "isRefetchError" | "isPreviousData" | "isOptimisticData" | "errorUpdatedAt" | "retryCount" | "isGoingToRetry" | "pageParam" | "pageParams" | "hasNextPage" | "retryNextPageCount" | "isGoingToRetryNextPage" | "isLoading" | "isSuccess" | "isError" | "responseUpdatedAt" | import("..").SelectDeps<QueryState<TKey, TResponse, TData, TError, TPageParam>>): {
-        data: (never[] | TData)[number][];
-        fetchPrevPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        hasPrevPage: boolean;
-        isWaitingPrevPage: boolean;
-        key: TKey;
-        keyHash: string;
-        fetch: () => void;
-        forceFetch: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        fetchNextPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        reset: () => void;
-        optimisticUpdate: (response: TResponse | ((prevState: QueryState<TKey, TResponse, TData, TError, TPageParam>) => TResponse)) => {
-            revert: () => void;
-            invalidate: () => void;
-        };
-        isWaiting: boolean;
-        isWaitingNextPage: boolean;
-        isRefetching: boolean;
-        isRefetchError: boolean;
-        isPreviousData: boolean;
-        isOptimisticData: boolean;
-        error: TError | undefined;
-        errorUpdatedAt: number | undefined;
-        retryCount: number;
-        isGoingToRetry: boolean;
-        pageParam: Maybe<TPageParam>;
-        pageParams: Maybe<TPageParam>[];
-        hasNextPage: boolean;
-        retryNextPageCount: number;
-        isGoingToRetryNextPage: boolean;
-        status: "loading";
-        isLoading: true;
-        isSuccess: false;
-        isError: false;
-        response: undefined;
-        responseUpdatedAt: undefined;
-    } | {
-        data: (never[] | TData)[number][];
-        fetchPrevPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        hasPrevPage: boolean;
-        isWaitingPrevPage: boolean;
-        key: TKey;
-        keyHash: string;
-        fetch: () => void;
-        forceFetch: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        fetchNextPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        reset: () => void;
-        optimisticUpdate: (response: TResponse | ((prevState: QueryState<TKey, TResponse, TData, TError, TPageParam>) => TResponse)) => {
-            revert: () => void;
-            invalidate: () => void;
-        };
-        isWaiting: boolean;
-        isWaitingNextPage: boolean;
-        isRefetching: boolean;
-        isRefetchError: boolean;
-        isPreviousData: boolean;
-        isOptimisticData: boolean;
-        error: TError | undefined;
-        errorUpdatedAt: number | undefined;
-        retryCount: number;
-        isGoingToRetry: boolean;
-        pageParam: Maybe<TPageParam>;
-        pageParams: Maybe<TPageParam>[];
-        hasNextPage: boolean;
-        retryNextPageCount: number;
-        isGoingToRetryNextPage: boolean;
-        status: "error";
-        isLoading: false;
-        isSuccess: false;
-        isError: true;
-        response: undefined;
-        responseUpdatedAt: undefined;
-    } | {
-        data: (never[] | TData)[number][];
-        fetchPrevPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        hasPrevPage: boolean;
-        isWaitingPrevPage: boolean;
-        key: TKey;
-        keyHash: string;
-        fetch: () => void;
-        forceFetch: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        fetchNextPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        reset: () => void;
-        optimisticUpdate: (response: TResponse | ((prevState: QueryState<TKey, TResponse, TData, TError, TPageParam>) => TResponse)) => {
-            revert: () => void;
-            invalidate: () => void;
-        };
-        isWaiting: boolean;
-        isWaitingNextPage: boolean;
-        isRefetching: boolean;
-        isRefetchError: boolean;
-        isPreviousData: boolean;
-        isOptimisticData: boolean;
-        error: TError | undefined;
-        errorUpdatedAt: number | undefined;
-        retryCount: number;
-        isGoingToRetry: boolean;
-        pageParam: Maybe<TPageParam>;
-        pageParams: Maybe<TPageParam>[];
-        hasNextPage: boolean;
-        retryNextPageCount: number;
-        isGoingToRetryNextPage: boolean;
-        status: "success";
-        isLoading: false;
-        isSuccess: true;
-        isError: false;
-        response: TResponse;
-        responseUpdatedAt: number | undefined;
-    };
-    get(): {
-        prev: QueryState<TKey, TResponse, TData, TError, TPageParam>;
-        next: QueryState<TKey, TResponse, TData, TError, TPageParam>;
-    };
-    setInitialResponse: (options: {
-        key?: Maybe<TKey>;
-        response: TResponse;
-        skipRevalidation?: boolean | undefined;
-    }) => void;
-    reset(): void;
-    resetSpecificKey(key: Maybe<TKey>): void;
-    invalidate: () => void;
-    invalidateSpecificKey: (key?: Maybe<TKey>) => void;
-    suspend: (key?: Maybe<TKey>) => {
-        key: TKey;
-        keyHash: string;
-        fetch: () => void;
-        forceFetch: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        fetchNextPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        reset: () => void;
-        optimisticUpdate: (response: TResponse | ((prevState: QueryState<TKey, TResponse, TData, TError, TPageParam>) => TResponse)) => {
-            revert: () => void;
-            invalidate: () => void;
-        };
-        isWaiting: boolean;
-        isWaitingNextPage: boolean;
-        isRefetching: boolean;
-        isRefetchError: boolean;
-        isPreviousData: boolean;
-        isOptimisticData: boolean;
-        error: TError | undefined;
-        errorUpdatedAt: number | undefined;
-        retryCount: number;
-        isGoingToRetry: boolean;
-        pageParam: Maybe<TPageParam>;
-        pageParams: Maybe<TPageParam>[];
-        hasNextPage: boolean;
-        retryNextPageCount: number;
-        isGoingToRetryNextPage: boolean;
-    } & {
-        status: "success";
-        isLoading: false;
-        isSuccess: true;
-        isError: false;
-        data: TData;
-        response: TResponse;
-        responseUpdatedAt: number | undefined;
-    };
-};

package/esm/react/create-bi-direction-query.js

@@ -1,74 +0,0 @@
-import { hasValue } from '../utils';
-import { createQuery } from './create-query';
-export const createBiDirectionQuery = (queryFn, options) => {
-    const { getPrevPageParam, getNextPageParam, select, ...restOptions } = options;
-    const usePrevPagesQuery = createQuery((key, state) => queryFn(key, state, 'prev'), {
-        defaultDeps: (state) => [
-            state.isWaiting,
-            state.data,
-            state.error,
-            state.isWaitingNextPage,
-            state.hasNextPage,
-        ],
-        fetchOnMount: false,
-        getNextPageParam: getPrevPageParam,
-        select: (response, state) => select(response, state, 'prev'),
-        ...restOptions,
-    });
-    const useNextPagesQuery = createQuery(async (key, state) => {
-        const isInitialPage = state.pageParam === undefined;
-        const pQuery = usePrevPagesQuery.get(key);
-        try {
-            const response = await queryFn(key, state, 'next');
-            if (isInitialPage) {
-                const prevPageParam = getPrevPageParam(response, 1, pQuery);
-                usePrevPagesQuery.set(key, (prev) => ({
-                    pageParams: [prevPageParam, ...prev.pageParams.slice(1)],
-                    hasNextPage: prev.isLoading ? hasValue(prevPageParam) : prev.hasNextPage,
-                }));
-                if (!pQuery.isLoading)
-                    pQuery.forceFetch();
-            }
-            return response;
-        }
-        catch (error) {
-            if (isInitialPage && !pQuery.isLoading)
-                pQuery.reset();
-            throw error;
-        }
-    }, {
-        getNextPageParam: getNextPageParam,
-        select: (response, state) => select(response, state, 'next'),
-        ...restOptions,
-    });
-    const useBiDirectionQuery = (...args) => {
-        const pQuery = usePrevPagesQuery(...args);
-        const nQuery = useNextPagesQuery(...args);
-        return {
-            ...nQuery,
-            data: [...(pQuery.data || []), ...(nQuery.data || [])],
-            fetchPrevPage: pQuery.fetchNextPage,
-            hasPrevPage: pQuery.hasNextPage,
-            isWaitingPrevPage: pQuery.isWaitingNextPage || (pQuery.isLoading && pQuery.isWaiting),
-        };
-    };
-    useBiDirectionQuery.get = () => {
-        return {
-            prev: usePrevPagesQuery.get(),
-            next: useNextPagesQuery.get(),
-        };
-    };
-    useBiDirectionQuery.setInitialResponse = useNextPagesQuery.setInitialResponse;
-    useBiDirectionQuery.reset = () => {
-        usePrevPagesQuery.reset();
-        useNextPagesQuery.reset();
-    };
-    useBiDirectionQuery.resetSpecificKey = (key) => {
-        usePrevPagesQuery.resetSpecificKey(key);
-        useNextPagesQuery.resetSpecificKey(key);
-    };
-    useBiDirectionQuery.invalidate = useNextPagesQuery.invalidate;
-    useBiDirectionQuery.invalidateSpecificKey = useNextPagesQuery.invalidateSpecificKey;
-    useBiDirectionQuery.suspend = useNextPagesQuery.suspend;
-    return useBiDirectionQuery;
-};

package/esm/react/create-mutation.d.ts

@@ -1,39 +0,0 @@
-import { InitStoreOptions } from '../store';
-import { UseStore } from './create-store';
-export type MutationState<TVar, TResponse = any, TError = unknown> = {
-    /**
-     * Network fetching status.
-     */
-    isWaiting: boolean;
-    isSuccess: boolean;
-    isError: boolean;
-    response: TResponse | undefined;
-    responseUpdatedAt: number | undefined;
-    error: TError | undefined;
-    errorUpdatedAt: number | undefined;
-    /**
-     * Mutate function.
-     *
-     * @returns Promise that will always get resolved.
-     */
-    mutate: TVar extends undefined ? () => Promise<{
-        response?: TResponse;
-        error?: TError;
-        variables?: TVar;
-    }> : (variables: TVar) => Promise<{
-        response?: TResponse;
-        error?: TError;
-        variables?: TVar;
-    }>;
-};
-export type UseMutation<TVar, TResponse = any, TError = unknown> = UseStore<MutationState<TVar, TResponse, TError>>;
-export type CreateMutationOptions<TVar, TResponse = any, TError = unknown> = InitStoreOptions<MutationState<TVar, TResponse, TError>> & {
-    onMutate?: (variables: TVar, stateBeforeMutate: MutationState<TVar, TResponse, TError>) => void;
-    onSuccess?: (response: TResponse, variables: TVar, stateBeforeMutate: MutationState<TVar, TResponse, TError>) => void;
-    onError?: (error: TError, variables: TVar, stateBeforeMutate: MutationState<TVar, TResponse, TError>) => void;
-    onSettled?: (variables: TVar, stateBeforeMutate: MutationState<TVar, TResponse, TError>) => void;
-};
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createmutation
- */
-export declare const createMutation: <TVar, TResponse = any, TError = unknown>(mutationFn: (variables: TVar, state: MutationState<TVar, TResponse, TError>) => Promise<TResponse>, options?: CreateMutationOptions<TVar, TResponse, TError>) => UseMutation<TVar, TResponse, TError>;

package/esm/react/create-mutation.js

@@ -1,56 +0,0 @@
-import { noop } from '../utils';
-import { createStore } from './create-store';
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createmutation
- */
-export const createMutation = (mutationFn, options = {}) => {
-    const { onMutate = noop, onSuccess = noop, onError, onSettled = noop, ...createStoreOptions } = options;
-    const useMutation = createStore(({ set, get }) => ({
-        isWaiting: false,
-        isSuccess: false,
-        isError: false,
-        response: undefined,
-        responseUpdatedAt: undefined,
-        error: undefined,
-        errorUpdatedAt: undefined,
-        mutate: ((variables) => {
-            set({ isWaiting: true });
-            const stateBeforeMutate = get();
-            onMutate(variables, stateBeforeMutate);
-            return new Promise((resolve) => {
-                mutationFn(variables, stateBeforeMutate)
-                    .then((response) => {
-                    set({
-                        isWaiting: false,
-                        isSuccess: true,
-                        isError: false,
-                        response,
-                        responseUpdatedAt: Date.now(),
-                        error: undefined,
-                        errorUpdatedAt: undefined,
-                    });
-                    onSuccess(response, variables, stateBeforeMutate);
-                    resolve({ response, variables });
-                })
-                    .catch((error) => {
-                    set({
-                        isWaiting: false,
-                        isSuccess: false,
-                        isError: true,
-                        error,
-                        errorUpdatedAt: Date.now(),
-                    });
-                    if (onError)
-                        onError(error, variables, stateBeforeMutate);
-                    else
-                        console.error(error, variables, get());
-                    resolve({ error, variables });
-                })
-                    .finally(() => {
-                    onSettled(variables, stateBeforeMutate);
-                });
-            });
-        }),
-    }), createStoreOptions);
-    return useMutation;
-};