@craft-native/react 0.0.72

package/dist/index.mjs

@@ -0,0 +1,608 @@
+// src/index.ts
+import { useEffect as useEffect4, useState as useState7, useCallback as useCallback8, useRef as useRef2, useMemo } from "react";
+
+// src/hooks/useWindow.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+
+// src/index.tsx
+import { useEffect, useState, useCallback } from "react";
+function useCraft() {
+  return window.craft;
+}
+
+// src/hooks/useWindow.ts
+function useWindow() {
+  const { craft, isReady } = useCraft();
+  const [isFullscreen, setIsFullscreen] = useState2(false);
+  const [isMaximized, setIsMaximized] = useState2(false);
+  const [isMinimized, setIsMinimized] = useState2(false);
+  const setTitle = useCallback2(
+    async (title) => {
+      if (!isReady || !craft) return;
+      await craft.invoke("window.setTitle", { title });
+    },
+    [craft, isReady]
+  );
+  const setSize = useCallback2(
+    async (width, height) => {
+      if (!isReady || !craft) return;
+      await craft.invoke("window.setSize", { width, height });
+    },
+    [craft, isReady]
+  );
+  const setPosition = useCallback2(
+    async (x, y) => {
+      if (!isReady || !craft) return;
+      await craft.invoke("window.setPosition", { x, y });
+    },
+    [craft, isReady]
+  );
+  const maximize = useCallback2(async () => {
+    if (!isReady || !craft) return;
+    await craft.invoke("window.maximize");
+    setIsMaximized(true);
+  }, [craft, isReady]);
+  const minimize = useCallback2(async () => {
+    if (!isReady || !craft) return;
+    await craft.invoke("window.minimize");
+    setIsMinimized(true);
+  }, [craft, isReady]);
+  const restore = useCallback2(async () => {
+    if (!isReady || !craft) return;
+    await craft.invoke("window.restore");
+    setIsMaximized(false);
+    setIsMinimized(false);
+  }, [craft, isReady]);
+  const toggleFullscreen = useCallback2(async () => {
+    if (!isReady || !craft) return;
+    await craft.invoke("window.toggleFullscreen");
+    setIsFullscreen(!isFullscreen);
+  }, [craft, isReady, isFullscreen]);
+  const close = useCallback2(async () => {
+    if (!isReady || !craft) return;
+    await craft.invoke("window.close");
+  }, [craft, isReady]);
+  const center = useCallback2(async () => {
+    if (!isReady || !craft) return;
+    await craft.invoke("window.center");
+  }, [craft, isReady]);
+  const setAlwaysOnTop = useCallback2(
+    async (alwaysOnTop) => {
+      if (!isReady || !craft) return;
+      await craft.invoke("window.setAlwaysOnTop", { alwaysOnTop });
+    },
+    [craft, isReady]
+  );
+  return {
+    isFullscreen,
+    isMaximized,
+    isMinimized,
+    setTitle,
+    setSize,
+    setPosition,
+    maximize,
+    minimize,
+    restore,
+    toggleFullscreen,
+    close,
+    center,
+    setAlwaysOnTop
+  };
+}
+
+// src/hooks/useTray.ts
+import { useCallback as useCallback3, useState as useState3 } from "react";
+function useTray() {
+  const { craft, isReady } = useCraft();
+  const [isVisible, setIsVisible] = useState3(false);
+  const create = useCallback3(
+    async (icon, tooltip) => {
+      if (!isReady || !craft) return;
+      await craft.invoke("tray.create", { icon, tooltip });
+      setIsVisible(true);
+    },
+    [craft, isReady]
+  );
+  const destroy = useCallback3(async () => {
+    if (!isReady || !craft) return;
+    await craft.invoke("tray.destroy");
+    setIsVisible(false);
+  }, [craft, isReady]);
+  const setIcon = useCallback3(
+    async (icon) => {
+      if (!isReady || !craft) return;
+      await craft.invoke("tray.setIcon", { icon });
+    },
+    [craft, isReady]
+  );
+  const setTooltip = useCallback3(
+    async (tooltip) => {
+      if (!isReady || !craft) return;
+      await craft.invoke("tray.setTooltip", { tooltip });
+    },
+    [craft, isReady]
+  );
+  const setMenu = useCallback3(
+    async (menu) => {
+      if (!isReady || !craft) return;
+      await craft.invoke("tray.setMenu", { menu });
+    },
+    [craft, isReady]
+  );
+  const setTitle = useCallback3(
+    async (title) => {
+      if (!isReady || !craft) return;
+      await craft.invoke("tray.setTitle", { title });
+    },
+    [craft, isReady]
+  );
+  return {
+    isVisible,
+    create,
+    destroy,
+    setIcon,
+    setTooltip,
+    setMenu,
+    setTitle
+  };
+}
+
+// src/hooks/useNotification.ts
+import { useCallback as useCallback4 } from "react";
+function useNotification() {
+  const { craft, isReady } = useCraft();
+  const send = useCallback4(
+    async (options) => {
+      if (!isReady || !craft) return;
+      await craft.invoke("notification.send", options);
+    },
+    [craft, isReady]
+  );
+  const requestPermission = useCallback4(async () => {
+    if (!isReady || !craft) return false;
+    const result = await craft.requestPermission("notifications");
+    return result.granted;
+  }, [craft, isReady]);
+  return {
+    send,
+    requestPermission
+  };
+}
+
+// src/hooks/useFileSystem.ts
+import { useCallback as useCallback5, useState as useState4 } from "react";
+function useFileSystem() {
+  const { craft, isReady } = useCraft();
+  const [loading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const readFile = useCallback5(
+    async (path, encoding = "utf8") => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await craft.invoke("fs.readFile", { path, encoding });
+        return result;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [craft, isReady]
+  );
+  const writeFile = useCallback5(
+    async (path, data, encoding = "utf8") => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      try {
+        await craft.invoke("fs.writeFile", { path, data, encoding });
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [craft, isReady]
+  );
+  const readDir = useCallback5(
+    async (path) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await craft.invoke("fs.readDir", { path });
+        return result;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [craft, isReady]
+  );
+  const mkdir = useCallback5(
+    async (path, recursive = false) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      try {
+        await craft.invoke("fs.mkdir", { path, recursive });
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [craft, isReady]
+  );
+  const remove = useCallback5(
+    async (path, recursive = false) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      try {
+        await craft.invoke("fs.remove", { path, recursive });
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [craft, isReady]
+  );
+  const exists = useCallback5(
+    async (path) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      try {
+        const result = await craft.invoke("fs.exists", { path });
+        return result;
+      } catch (err) {
+        setError(err);
+        return false;
+      }
+    },
+    [craft, isReady]
+  );
+  const stat = useCallback5(
+    async (path) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await craft.invoke("fs.stat", { path });
+        return result;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [craft, isReady]
+  );
+  return {
+    readFile,
+    writeFile,
+    readDir,
+    mkdir,
+    remove,
+    exists,
+    stat,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useDatabase.ts
+import { useCallback as useCallback6, useState as useState5 } from "react";
+function useDatabase(dbPath) {
+  const { craft, isReady } = useCraft();
+  const [loading, setLoading] = useState5(false);
+  const [error, setError] = useState5(null);
+  const execute = useCallback6(
+    async (sql, params = []) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await craft.invoke("db.execute", { path: dbPath, sql, params });
+        return result;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [craft, isReady, dbPath]
+  );
+  const query = useCallback6(
+    async (sql, params = []) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await craft.invoke("db.query", { path: dbPath, sql, params });
+        return result;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [craft, isReady, dbPath]
+  );
+  const transaction = useCallback6(
+    async (callback) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      try {
+        await craft.invoke("db.transaction.begin", { path: dbPath });
+        try {
+          await callback({
+            execute: async (sql, params = []) => {
+              return await craft.invoke("db.execute", { path: dbPath, sql, params });
+            }
+          });
+          await craft.invoke("db.transaction.commit", { path: dbPath });
+        } catch (err) {
+          await craft.invoke("db.transaction.rollback", { path: dbPath });
+          throw err;
+        }
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [craft, isReady, dbPath]
+  );
+  return {
+    execute,
+    query,
+    transaction,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useHttp.ts
+import { useCallback as useCallback7, useState as useState6 } from "react";
+function useHttp() {
+  const { craft, isReady } = useCraft();
+  const [loading, setLoading] = useState6(false);
+  const [error, setError] = useState6(null);
+  const fetch = useCallback7(
+    async (url, options = {}) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await craft.invoke("http.fetch", { url, ...options });
+        return result;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [craft, isReady]
+  );
+  const download = useCallback7(
+    async (url, path, options = {}) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      if (options.onProgress) {
+        craft.on("download.progress", options.onProgress);
+      }
+      try {
+        await craft.invoke("http.download", { url, path });
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        if (options.onProgress) {
+          craft.off("download.progress", options.onProgress);
+        }
+        setLoading(false);
+      }
+    },
+    [craft, isReady]
+  );
+  const upload = useCallback7(
+    async (url, filePath, options = {}) => {
+      if (!isReady || !craft) throw new Error("Craft not ready");
+      setLoading(true);
+      setError(null);
+      if (options.onProgress) {
+        craft.on("upload.progress", options.onProgress);
+      }
+      try {
+        const result = await craft.invoke("http.upload", { url, filePath, ...options });
+        return result;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        if (options.onProgress) {
+          craft.off("upload.progress", options.onProgress);
+        }
+        setLoading(false);
+      }
+    },
+    [craft, isReady]
+  );
+  return {
+    fetch,
+    download,
+    upload,
+    loading,
+    error
+  };
+}
+
+// src/index.ts
+function useCraft2() {
+  const [craft, setCraft] = useState7(null);
+  const [isReady, setIsReady] = useState7(false);
+  useEffect4(() => {
+    if (window.craft) {
+      setCraft(window.craft);
+      setIsReady(true);
+    } else {
+      const checkCraft = setInterval(() => {
+        if (window.craft) {
+          setCraft(window.craft);
+          setIsReady(true);
+          clearInterval(checkCraft);
+        }
+      }, 100);
+      return () => clearInterval(checkCraft);
+    }
+  }, []);
+  return { craft, isReady };
+}
+function usePlatform() {
+  const { craft, isReady } = useCraft2();
+  const [platform, setPlatform] = useState7(null);
+  const [loading, setLoading] = useState7(true);
+  const [error, setError] = useState7(null);
+  useEffect4(() => {
+    if (!isReady || !craft) return;
+    craft.getPlatform().then(setPlatform).catch(setError).finally(() => setLoading(false));
+  }, [craft, isReady]);
+  return { platform, loading, error };
+}
+function useDeviceInfo() {
+  const { craft, isReady } = useCraft2();
+  const [deviceInfo, setDeviceInfo] = useState7(null);
+  const [loading, setLoading] = useState7(true);
+  const [error, setError] = useState7(null);
+  useEffect4(() => {
+    if (!isReady || !craft) return;
+    craft.getDeviceInfo().then(setDeviceInfo).catch(setError).finally(() => setLoading(false));
+  }, [craft, isReady]);
+  return { deviceInfo, loading, error };
+}
+function useToast() {
+  const { craft, isReady } = useCraft2();
+  const showToast = useCallback8(
+    async (message, duration = "short") => {
+      if (!isReady || !craft) {
+        console.warn("Craft not ready");
+        return;
+      }
+      await craft.showToast(message, duration);
+    },
+    [craft, isReady]
+  );
+  return { showToast };
+}
+function useHaptic() {
+  const { craft, isReady } = useCraft2();
+  const haptic = useCallback8(
+    async (type = "selection") => {
+      if (!isReady || !craft) {
+        console.warn("Craft not ready");
+        return;
+      }
+      await craft.haptic(type);
+    },
+    [craft, isReady]
+  );
+  return { haptic };
+}
+function usePermission(permission) {
+  const { craft, isReady } = useCraft2();
+  const [granted, setGranted] = useState7(null);
+  const [loading, setLoading] = useState7(false);
+  const [error, setError] = useState7(null);
+  const request = useCallback8(async () => {
+    if (!isReady || !craft) {
+      console.warn("Craft not ready");
+      return;
+    }
+    setLoading(true);
+    try {
+      const result = await craft.requestPermission(permission);
+      setGranted(result.granted);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [craft, isReady, permission]);
+  return { granted, request, loading, error };
+}
+function useCraftEvent(event, callback) {
+  const { craft, isReady } = useCraft2();
+  const callbackRef = useRef2(callback);
+  useEffect4(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  useEffect4(() => {
+    if (!isReady || !craft) return;
+    const handler = (...args) => callbackRef.current(...args);
+    craft.on(event, handler);
+    return () => {
+      craft.off(event, handler);
+    };
+  }, [craft, isReady, event]);
+}
+function useCraftInvoke() {
+  const { craft, isReady } = useCraft2();
+  const invoke = useCallback8(
+    async (method, params) => {
+      if (!isReady || !craft) {
+        throw new Error("Craft not ready");
+      }
+      return await craft.invoke(method, params);
+    },
+    [craft, isReady]
+  );
+  return { invoke, isReady };
+}
+function useIsMobile() {
+  const { platform } = usePlatform();
+  return useMemo(() => {
+    if (!platform) return false;
+    return platform.platform === "ios" || platform.platform === "android";
+  }, [platform]);
+}
+function useIsDesktop() {
+  const { platform } = usePlatform();
+  return useMemo(() => {
+    if (!platform) return false;
+    return platform.platform === "macos" || platform.platform === "windows" || platform.platform === "linux";
+  }, [platform]);
+}
+export {
+  useCraft2 as useCraft,
+  useCraftEvent,
+  useCraftInvoke,
+  useDatabase,
+  useDeviceInfo,
+  useFileSystem,
+  useHaptic,
+  useHttp,
+  useIsDesktop,
+  useIsMobile,
+  useNotification,
+  usePermission,
+  usePlatform,
+  useToast,
+  useTray,
+  useWindow
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@craft-native/react",
+  "version": "0.0.72",
+  "homepage": "https://github.com/craft-native/craft/tree/main/packages/react#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/craft-native/craft.git",
+    "directory": "packages/react"
+  },
+  "bugs": {
+    "url": "https://github.com/craft-native/craft/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "description": "React bindings for Craft framework",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm && tsc --emitDeclarationOnly",
+    "dev": "tsup src/index.ts --format cjs,esm --watch"
+  },
+  "keywords": [
+    "craft",
+    "react",
+    "hooks",
+    "native",
+    "mobile",
+    "desktop"
+  ],
+  "author": "Craft Team",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=16.8.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "react": "^18.2.0",
+    "tsup": "^8.0.0",
+    "typescript": "^7.0.2"
+  }
+}