@hirall/react/dist/index.js

React hooks and components for Hirall

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.tsx
var index_exports = {};
__export(index_exports, {
  HirallClient: () => import_client.HirallClient,
  HirallProvider: () => HirallProvider,
  useAuth: () => useAuth,
  useHirall: () => useHirall,
  useMutation: () => useMutation,
  useQuery: () => useQuery,
  useRealtime: () => useRealtime,
  useStorage: () => useStorage
});
module.exports = __toCommonJS(index_exports);
var import_react = require("react");
var import_client = require("@hirall/client");
var HirallContext = (0, import_react.createContext)(null);
function HirallProvider({ client, children }) {
  return /* @__PURE__ */ React.createElement(HirallContext.Provider, { value: client }, children);
}
function useHirall() {
  const client = (0, import_react.useContext)(HirallContext);
  if (!client) {
    throw new Error("useHirall must be used within HirallProvider");
  }
  return client;
}
function useAuth() {
  const hirall = useHirall();
  const [user, setUser] = (0, import_react.useState)(null);
  const [session, setSession] = (0, import_react.useState)(null);
  const [loading, setLoading] = (0, import_react.useState)(true);
  (0, import_react.useEffect)(() => {
    hirall.auth.getSession().then(({ data }) => {
      setSession(data);
      setUser((data == null ? void 0 : data.user) || null);
      setLoading(false);
    });
    const { unsubscribe } = hirall.auth.onAuthStateChange((event) => {
      var _a;
      setSession(event.session);
      setUser(((_a = event.session) == null ? void 0 : _a.user) || null);
    });
    return () => {
      unsubscribe();
    };
  }, [hirall]);
  const signUp = (0, import_react.useCallback)(
    async (email, password) => {
      const result = await hirall.auth.signUp({ email, password });
      if (result.data) {
        setSession(result.data);
        setUser(result.data.user);
      }
      return result;
    },
    [hirall]
  );
  const signIn = (0, import_react.useCallback)(
    async (email, password) => {
      const result = await hirall.auth.signIn({ email, password });
      if (result.data) {
        setSession(result.data);
        setUser(result.data.user);
      }
      return result;
    },
    [hirall]
  );
  const signOut = (0, import_react.useCallback)(async () => {
    const result = await hirall.auth.signOut();
    setSession(null);
    setUser(null);
    return result;
  }, [hirall]);
  return {
    user,
    session,
    loading,
    signUp,
    signIn,
    signOut
  };
}
function useQuery(queryFn, options) {
  const [data, setData] = (0, import_react.useState)(null);
  const [loading, setLoading] = (0, import_react.useState)(true);
  const [error, setError] = (0, import_react.useState)(null);
  const fetchData = (0, import_react.useCallback)(async () => {
    var _a, _b, _c;
    try {
      setLoading(true);
      const result = await queryFn();
      if (result.error) {
        setError(result.error);
        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, result.error);
      } else {
        setData(result.data);
        (_b = options == null ? void 0 : options.onSuccess) == null ? void 0 : _b.call(options, result.data);
      }
    } catch (err) {
      setError(err);
      (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, err);
    } finally {
      setLoading(false);
    }
  }, [queryFn, options]);
  (0, import_react.useEffect)(() => {
    if ((options == null ? void 0 : options.enabled) !== false) {
      fetchData();
    }
    if (options == null ? void 0 : options.refetchInterval) {
      const interval = setInterval(fetchData, options.refetchInterval);
      return () => clearInterval(interval);
    }
  }, [fetchData, options == null ? void 0 : options.enabled, options == null ? void 0 : options.refetchInterval]);
  return {
    data,
    loading,
    error,
    refetch: fetchData
  };
}
function useMutation(mutationFn, options) {
  const [data, setData] = (0, import_react.useState)(null);
  const [loading, setLoading] = (0, import_react.useState)(false);
  const [error, setError] = (0, import_react.useState)(null);
  const mutate = (0, import_react.useCallback)(
    async (variables) => {
      var _a, _b, _c;
      try {
        setLoading(true);
        setError(null);
        const result = await mutationFn(variables);
        if (result.error) {
          setError(result.error);
          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, result.error, variables);
        } else {
          setData(result.data);
          (_b = options == null ? void 0 : options.onSuccess) == null ? void 0 : _b.call(options, result.data, variables);
        }
        return result;
      } catch (err) {
        setError(err);
        (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, err, variables);
        return { data: null, error: err, status: 0 };
      } finally {
        setLoading(false);
      }
    },
    [mutationFn, options]
  );
  return {
    mutate,
    loading,
    error,
    data
  };
}
function useRealtime(channelName, event, options) {
  const hirall = useHirall();
  const [connected, setConnected] = (0, import_react.useState)(false);
  (0, import_react.useEffect)(() => {
    const channel = hirall.realtime.channel(channelName).on(event, (payload) => {
      var _a;
      (_a = options == null ? void 0 : options.onMessage) == null ? void 0 : _a.call(options, payload);
    }).subscribe();
    hirall.realtime.connect();
    setConnected(true);
    return () => {
      channel.unsubscribe();
      setConnected(false);
    };
  }, [hirall, channelName, event, options]);
  const send = (0, import_react.useCallback)(
    (eventName, payload) => {
      hirall.realtime.channel(channelName).send(eventName, payload);
    },
    [hirall, channelName]
  );
  return {
    send,
    connected
  };
}
function useStorage(bucketName) {
  const hirall = useHirall();
  const [uploading, setUploading] = (0, import_react.useState)(false);
  const [error, setError] = (0, import_react.useState)(null);
  const upload = (0, import_react.useCallback)(
    async (path, file) => {
      try {
        setUploading(true);
        setError(null);
        const result = await hirall.storage.bucket(bucketName).upload(path, file);
        if (result.error) {
          setError(result.error);
        }
        return result;
      } catch (err) {
        setError(err);
        return { data: null, error: err, status: 0 };
      } finally {
        setUploading(false);
      }
    },
    [hirall, bucketName]
  );
  const download = (0, import_react.useCallback)(
    async (path) => {
      try {
        setError(null);
        const result = await hirall.storage.bucket(bucketName).download(path);
        if (result.error) {
          setError(result.error);
        }
        return result;
      } catch (err) {
        setError(err);
        return { data: null, error: err, status: 0 };
      }
    },
    [hirall, bucketName]
  );
  const remove = (0, import_react.useCallback)(
    async (path) => {
      try {
        setError(null);
        const result = await hirall.storage.bucket(bucketName).delete(path);
        if (result.error) {
          setError(result.error);
        }
        return result;
      } catch (err) {
        setError(err);
        return { data: null, error: err, status: 0 };
      }
    },
    [hirall, bucketName]
  );
  const getUrl = (0, import_react.useCallback)(
    async (path) => {
      try {
        setError(null);
        const result = await hirall.storage.bucket(bucketName).getSignedUrl(path);
        if (result.error) {
          setError(result.error);
        }
        return result;
      } catch (err) {
        setError(err);
        return { data: null, error: err, status: 0 };
      }
    },
    [hirall, bucketName]
  );
  return {
    upload,
    download,
    remove,
    getUrl,
    uploading,
    error
  };
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  HirallClient,
  HirallProvider,
  useAuth,
  useHirall,
  useMutation,
  useQuery,
  useRealtime,
  useStorage
});