@pixotope/query 0.0.1

package/dist/index.js

@@ -0,0 +1,674 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// ../utils/dist/comparison/index.js
+var require_comparison = __commonJS({
+  "../utils/dist/comparison/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var comparison_exports = {};
+    __export(comparison_exports, {
+      shallowEqual: () => shallowEqual2
+    });
+    module.exports = __toCommonJS(comparison_exports);
+    function shallowEqual2(objA, objB) {
+      if (Object.is(objA, objB)) {
+        return true;
+      }
+      if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+        return false;
+      }
+      if (objA instanceof Map && objB instanceof Map) {
+        if (objA.size !== objB.size) return false;
+        for (const [key, value] of objA) {
+          if (!Object.is(value, objB.get(key))) {
+            return false;
+          }
+        }
+        return true;
+      }
+      if (objA instanceof Set && objB instanceof Set) {
+        if (objA.size !== objB.size) return false;
+        for (const value of objA) {
+          if (!objB.has(value)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      const keysA = Object.keys(objA);
+      if (keysA.length !== Object.keys(objB).length) {
+        return false;
+      }
+      for (let i = 0; i < keysA.length; i++) {
+        if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !Object.is(objA[keysA[i]], objB[keysA[i]])) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+});
+
+// src/factories.ts
+import { useCallback as useCallback3, useMemo } from "react";
+
+// src/useMutation.ts
+import { useCallback, useRef, useState } from "react";
+var ComparisonFailError = class _ComparisonFailError extends Error {
+  constructor(message, payload) {
+    super(message);
+    __publicField(this, "payload");
+    this.name = this.constructor.name;
+    this.payload = payload;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ComparisonFailError);
+    }
+  }
+};
+var useMutation = (options) => {
+  const {
+    mutationFn,
+    compareOrThrow,
+    onError,
+    onSettled,
+    onSuccess,
+    prepareParams,
+    params,
+    timeout
+  } = options;
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const [result, setResult] = useState(void 0);
+  const mutationFnRef = useRef(mutationFn);
+  const internalOptionsRef = useRef({
+    params,
+    timeout
+  });
+  const internalCallbackRefistry = {
+    onSuccess,
+    onError,
+    onSettled,
+    compareOrThrow,
+    prepareParams
+  };
+  const internalCallbackRef = useRef(internalCallbackRefistry);
+  internalCallbackRef.current = internalCallbackRefistry;
+  const mutateAsync = useCallback(
+    (params2, overrideTargetMachine) => __async(null, null, function* () {
+      var _a, _b, _c, _d, _e, _f;
+      setStatus("loading");
+      setError(null);
+      try {
+        const promises = [
+          mutationFnRef.current(
+            internalCallbackRef.current.prepareParams ? internalCallbackRef.current.prepareParams(
+              params2,
+              internalOptionsRef.current.params
+            ) : params2,
+            overrideTargetMachine
+          ),
+          ...internalOptionsRef.current.timeout ? [
+            new Promise(
+              (resolve) => setTimeout(
+                () => resolve("timeout"),
+                internalOptionsRef.current.timeout
+              )
+            )
+          ] : []
+        ];
+        const res = yield Promise.race(promises);
+        if (res === "timeout") {
+          throw new Error("timeout");
+        }
+        if ((_b = (_a = internalCallbackRef.current).compareOrThrow) == null ? void 0 : _b.call(_a, res)) {
+          throw new ComparisonFailError(JSON.stringify(res), res);
+        }
+        setResult(res);
+        setStatus("success");
+        (_d = (_c = internalCallbackRef.current).onSuccess) == null ? void 0 : _d.call(_c, res, params2);
+        (_f = (_e = internalCallbackRef.current).onSettled) == null ? void 0 : _f.call(_e, res, null, params2);
+        return res;
+      } catch (error2) {
+        setError(error2);
+        setStatus("error");
+        if (internalCallbackRef.current.onError) {
+          internalCallbackRef.current.onError(error2, params2);
+        }
+        if (internalCallbackRef.current.onSettled) {
+          internalCallbackRef.current.onSettled(void 0, error2, params2);
+        }
+        throw error2;
+      }
+    }),
+    []
+  );
+  const mutate = useCallback(
+    (variables, options2) => {
+      mutateAsync(variables, options2 == null ? void 0 : options2.overrideTargetMachine).then(
+        (data) => {
+          var _a, _b;
+          (_a = options2 == null ? void 0 : options2.onSuccess) == null ? void 0 : _a.call(options2, data, variables);
+          (_b = options2 == null ? void 0 : options2.onSettled) == null ? void 0 : _b.call(options2, data, null, variables);
+        },
+        (error2) => {
+          var _a, _b;
+          (_a = options2 == null ? void 0 : options2.onError) == null ? void 0 : _a.call(options2, error2, variables);
+          (_b = options2 == null ? void 0 : options2.onSettled) == null ? void 0 : _b.call(options2, void 0, error2, variables);
+        }
+      );
+    },
+    [mutateAsync]
+  );
+  return {
+    mutateAsync,
+    status,
+    result,
+    mutate,
+    reset: () => setStatus("idle"),
+    error
+  };
+};
+
+// src/useQuery.ts
+import { useCallback as useCallback2, useEffect, useRef as useRef2, useState as useState2 } from "react";
+function normalizeQueryKey(queryKey) {
+  return JSON.stringify(queryKey);
+}
+var useQuery = (_a) => {
+  var _b = _a, {
+    queryFn
+  } = _b, options = __objRest(_b, [
+    "queryFn"
+  ]);
+  const {
+    enabled = true,
+    refetchOnWindowFocus = false,
+    refetchInterval = 0,
+    initialData,
+    select,
+    onError,
+    onSuccess,
+    onSettled,
+    timeout,
+    compareOrThrow,
+    stateless,
+    key: queryKeyPassed
+  } = options;
+  const queryKey = normalizeQueryKey(queryKeyPassed != null ? queryKeyPassed : []);
+  const promiseResolutionInProgress = useRef2(false);
+  const lastFetchedAt = useRef2(null);
+  const lastQueryKey = useRef2(void 0);
+  const queryFnRef = useRef2(queryFn);
+  queryFnRef.current = queryFn;
+  const internalCallbackRef = useRef2({});
+  internalCallbackRef.current = {
+    onError,
+    onSuccess,
+    onSettled,
+    compareOrThrow,
+    select
+  };
+  const internalOptionsRef = useRef2({
+    enabled,
+    refetchOnWindowFocus,
+    refetchInterval,
+    compareOrThrow,
+    stateless,
+    timeout
+  });
+  internalOptionsRef.current = {
+    enabled,
+    refetchOnWindowFocus,
+    refetchInterval,
+    compareOrThrow,
+    stateless,
+    timeout
+  };
+  const [status, setStatus] = useState2(() => {
+    return "idle";
+  });
+  const [error, setError] = useState2(null);
+  const [data, setData] = useState2(() => {
+    if (initialData !== void 0) {
+      if (typeof initialData === "function") {
+        return initialData();
+      }
+      return initialData;
+    }
+    return void 0;
+  });
+  const handleSetData = useCallback2((data2) => {
+    if (internalOptionsRef.current.stateless) {
+      return;
+    }
+    setData(data2);
+  }, []);
+  const shouldRefetch = useCallback2(() => {
+    var _a2;
+    if (!internalOptionsRef.current.enabled) {
+      return false;
+    }
+    if (lastFetchedAt.current === null) {
+      return true;
+    }
+    return (/* @__PURE__ */ new Date()).getTime() - lastFetchedAt.current > ((_a2 = internalOptionsRef.current) == null ? void 0 : _a2.refetchInterval);
+  }, []);
+  const refetch = useCallback2(
+    (params = void 0) => __async(null, null, function* () {
+      var _a2, _b2, _c, _d, _e, _f, _g, _h;
+      if (promiseResolutionInProgress.current || !internalOptionsRef.current.enabled) {
+        return;
+      }
+      setStatus("loading");
+      setError(null);
+      try {
+        const promises = [
+          queryFnRef.current(params),
+          ...internalOptionsRef.current.timeout ? [
+            new Promise(
+              (resolve) => setTimeout(
+                () => resolve("timeout"),
+                internalOptionsRef.current.timeout
+              )
+            )
+          ] : []
+        ];
+        promiseResolutionInProgress.current = true;
+        const res = yield Promise.race(promises);
+        promiseResolutionInProgress.current = false;
+        if (res === "timeout") {
+          throw new Error("timeout");
+        }
+        handleSetData(res);
+        if (internalCallbackRef.current.compareOrThrow && internalCallbackRef.current.compareOrThrow(res) === true) {
+          throw new Error("compareOrThrow");
+        }
+        setStatus("success");
+        lastFetchedAt.current = (/* @__PURE__ */ new Date()).getTime();
+        (_b2 = (_a2 = internalCallbackRef.current).onSuccess) == null ? void 0 : _b2.call(_a2, res);
+        (_d = (_c = internalCallbackRef.current).onSettled) == null ? void 0 : _d.call(_c, res, void 0);
+      } catch (error2) {
+        setError(error2);
+        setStatus("error");
+        (_f = (_e = internalCallbackRef.current).onError) == null ? void 0 : _f.call(_e, error2);
+        (_h = (_g = internalCallbackRef.current).onSettled) == null ? void 0 : _h.call(_g, void 0, error2);
+      }
+    }),
+    [handleSetData]
+  );
+  const reset = useCallback2(() => {
+    setData(void 0);
+    setStatus("idle");
+    setError(null);
+    refetch();
+  }, [refetch]);
+  useEffect(() => {
+    if (enabled) {
+      refetch();
+    }
+  }, [enabled, refetch, queryKey]);
+  useEffect(() => {
+    if (lastQueryKey.current === void 0) {
+      lastQueryKey.current = queryKey;
+      refetch();
+      return;
+    }
+    if (queryKey !== lastQueryKey.current) {
+      lastQueryKey.current = queryKey;
+      refetch();
+    }
+  }, [queryKey, refetch, enabled]);
+  useEffect(() => {
+    if (refetchOnWindowFocus) {
+      const queryHandleFocus = () => {
+        if (shouldRefetch()) {
+          refetch();
+        }
+      };
+      window.addEventListener("focus", queryHandleFocus);
+      return () => {
+        window.removeEventListener("focus", queryHandleFocus);
+      };
+    }
+  }, [refetchOnWindowFocus, refetch, shouldRefetch]);
+  useEffect(() => {
+    if (refetchInterval !== 0) {
+      const interval = setInterval(
+        () => {
+          if (shouldRefetch()) {
+            refetch();
+          }
+        },
+        Math.max(refetchInterval, 1e3)
+      );
+      return () => {
+        clearInterval(interval);
+      };
+    }
+  }, [refetch, refetchInterval, shouldRefetch]);
+  return {
+    data: select && data !== void 0 ? select(data) : data,
+    error,
+    status,
+    refetch,
+    reset
+  };
+};
+
+// src/factories.ts
+var useCallMutationBase = (clientProxy, functionName, service, options) => {
+  const _a = useMemo(() => options != null ? options : {}, [options]), {
+    avoidTimeout = true,
+    customTimeout = void 0
+  } = _a, rest = __objRest(_a, [
+    "avoidTimeout",
+    "customTimeout"
+  ]);
+  const mutationFn = useCallback3(
+    (parameters) => __async(null, null, function* () {
+      try {
+        const res = yield clientProxy.callAsync({
+          service,
+          functionName: functionName.toString(),
+          parameters,
+          options: {
+            avoidTimeout,
+            customTimeout
+          }
+        });
+        return res.message.Result;
+      } catch (e) {
+        throw e.message;
+      }
+    }),
+    [avoidTimeout, customTimeout, functionName, service]
+  );
+  return useMutation(__spreadValues({
+    mutationFn
+  }, rest));
+};
+function buildMutationHook(socketClientProxy, genTargetService) {
+  return function useCallMutationBuilder(func, options) {
+    const targetService = genTargetService(options == null ? void 0 : options.machine);
+    return useCallMutationBase(socketClientProxy, func, targetService, options);
+  };
+}
+var useCallQueryBase = (clientProxy, functionName, params, service, options) => {
+  const _a = useMemo(() => options != null ? options : {}, [options]), {
+    avoidTimeout = true,
+    customTimeout = void 0
+  } = _a, rest = __objRest(_a, [
+    "avoidTimeout",
+    "customTimeout"
+  ]);
+  const queryFn = useCallback3(
+    (refetchParams, overrideTargetMachine) => __async(null, null, function* () {
+      try {
+        const res = yield clientProxy.callAsync({
+          service: overrideTargetMachine != null ? overrideTargetMachine : service,
+          functionName: functionName.toString(),
+          parameters: refetchParams != null ? refetchParams : params,
+          options: {
+            avoidTimeout,
+            customTimeout
+          }
+        });
+        return res.message.Result;
+      } catch (e) {
+        if (e instanceof Error) {
+          throw e;
+        }
+        throw new Error(e);
+      }
+    }),
+    [avoidTimeout, customTimeout, functionName, service, params]
+  );
+  return useQuery(__spreadValues({
+    queryFn
+  }, rest));
+};
+function buildQueryHook(clientSocketProxy, getTargetService) {
+  return function useCallQueryBuilder(func, params, options) {
+    const targetService = getTargetService(options == null ? void 0 : options.machine);
+    return useCallQueryBase(clientSocketProxy, func, params, targetService, options);
+  };
+}
+
+// src/useSubscriptionCore.ts
+var import_comparison = __toESM(require_comparison(), 1);
+import { useCallback as useCallback4, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef3, useState as useState3 } from "react";
+function useSubscriptionCore(options) {
+  const {
+    enabled = true,
+    initialState = void 0,
+    onSubscribed,
+    stateless,
+    compareOrThrow,
+    subscriberFn,
+    onMessage,
+    onError,
+    select,
+    isEqual = import_comparison.shallowEqual
+  } = options;
+  const [status, setStatus] = useState3("idle");
+  const [data, setData] = useState3(initialState);
+  const unsubcribeRef = useRef3(void 0);
+  const initialStateRef = useRef3(initialState);
+  const subscriberFnRef = useRef3(subscriberFn);
+  const callbackRefRegistry = {
+    onMessage,
+    onError,
+    select,
+    compareOrThrow,
+    onSubscribed,
+    isEqual
+  };
+  const internalCallbacksRef = useRef3(callbackRefRegistry);
+  internalCallbacksRef.current = callbackRefRegistry;
+  const updateStatus = useCallback4(
+    (newStatus, message) => {
+      if (stateless) {
+        return;
+      }
+      setStatus((prev) => {
+        var _a, _b;
+        if (prev === newStatus) {
+          return prev;
+        }
+        if (newStatus === "subscribed" && message) {
+          (_b = (_a = internalCallbacksRef.current).onSubscribed) == null ? void 0 : _b.call(_a, message);
+        }
+        return newStatus;
+      });
+    },
+    [stateless]
+  );
+  const connection = useMemo2(
+    () => ({
+      acknowledge: () => {
+        updateStatus("subscribed");
+      }
+    }),
+    [updateStatus]
+  );
+  const handler = useCallback4(
+    (message) => __async(null, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+      if ((_b = (_a = internalCallbacksRef.current).compareOrThrow) == null ? void 0 : _b.call(_a, message)) {
+        (_d = (_c = internalCallbacksRef.current).onError) == null ? void 0 : _d.call(_c, message);
+        return;
+      }
+      const selectedMessage = (_g = (_f = (_e = internalCallbacksRef.current).select) == null ? void 0 : _f.call(_e, message)) != null ? _g : message;
+      if (!stateless) {
+        setData((prev) => {
+          if (isEqual(prev, selectedMessage)) {
+            return prev;
+          }
+          return selectedMessage;
+        });
+      }
+      updateStatus("subscribed", message);
+      (_i = (_h = internalCallbacksRef.current).onMessage) == null ? void 0 : _i.call(_h, message);
+    }),
+    [stateless, updateStatus]
+  );
+  const unsubscribe = useCallback4(() => {
+    var _a;
+    updateStatus("idle");
+    (_a = unsubcribeRef.current) == null ? void 0 : _a.call(unsubcribeRef);
+    unsubcribeRef.current = void 0;
+  }, [updateStatus]);
+  const subscribe = useCallback4(() => {
+    var _a;
+    (_a = unsubcribeRef.current) == null ? void 0 : _a.call(unsubcribeRef);
+    updateStatus("subscribing");
+    setData(initialStateRef.current);
+    unsubcribeRef.current = subscriberFnRef.current(handler, connection);
+  }, [connection, handler, updateStatus]);
+  useEffect2(() => {
+    if (enabled) {
+      subscribe();
+    } else {
+      unsubscribe();
+    }
+    return () => {
+      unsubscribe();
+    };
+  }, [enabled, subscribe, unsubscribe]);
+  return {
+    status,
+    data,
+    reSubscribe: subscribe
+  };
+}
+
+// src/useSubscription.ts
+function useSubscription(subscriptionHandler, options) {
+  const { topic, service, maxDownwardDepth = 1e3 } = options;
+  return useSubscriptionCore(__spreadProps(__spreadValues({}, options), {
+    subscriberFn: (handler) => {
+      const unsubscribe = subscriptionHandler({
+        service,
+        topic,
+        callback: (message) => {
+          handler(message);
+        },
+        maxDownwardDepth
+      });
+      return unsubscribe;
+    }
+  }));
+}
+function buildServiceSubscriptionHook(subscriptionHandler, targetMachine) {
+  return function useSubscriptionBuilder(options) {
+    const targetService = targetMachine(options.machine);
+    return useSubscription(
+      subscriptionHandler,
+      __spreadValues({
+        service: targetService
+      }, options)
+    );
+  };
+}
+function bindClientSocketProxy(socketClientProxy) {
+  return (...args) => socketClientProxy.mirror(...args)[0];
+}
+export {
+  bindClientSocketProxy,
+  buildMutationHook,
+  buildQueryHook,
+  buildServiceSubscriptionHook,
+  useQuery,
+  useSubscription
+};
+//# sourceMappingURL=index.js.map