@craft-native/vue 0.0.91 → 0.0.94

package/dist/index.mjs

@@ -0,0 +1,541 @@
+// src/index.ts
+import { ref as ref6, onMounted, onUnmounted, computed, watch } from "vue";
+
+// src/composables/useWindow.ts
+import { ref } from "vue";
+function useWindow() {
+  const { craft, isReady } = useCraft();
+  const isFullscreen = ref(false);
+  const isMaximized = ref(false);
+  const isMinimized = ref(false);
+  const setTitle = async (title) => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("window.setTitle", { title });
+  };
+  const setSize = async (width, height) => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("window.setSize", { width, height });
+  };
+  const setPosition = async (x, y) => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("window.setPosition", { x, y });
+  };
+  const maximize = async () => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("window.maximize");
+    isMaximized.value = true;
+  };
+  const minimize = async () => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("window.minimize");
+    isMinimized.value = true;
+  };
+  const restore = async () => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("window.restore");
+    isMaximized.value = false;
+    isMinimized.value = false;
+  };
+  const toggleFullscreen = async () => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("window.toggleFullscreen");
+    isFullscreen.value = !isFullscreen.value;
+  };
+  const close = async () => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("window.close");
+  };
+  const center = async () => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("window.center");
+  };
+  const setAlwaysOnTop = async (alwaysOnTop) => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("window.setAlwaysOnTop", { alwaysOnTop });
+  };
+  return {
+    isFullscreen,
+    isMaximized,
+    isMinimized,
+    setTitle,
+    setSize,
+    setPosition,
+    maximize,
+    minimize,
+    restore,
+    toggleFullscreen,
+    close,
+    center,
+    setAlwaysOnTop
+  };
+}
+
+// src/composables/useTray.ts
+import { ref as ref2 } from "vue";
+function useTray() {
+  const { craft, isReady } = useCraft();
+  const isVisible = ref2(false);
+  const create = async (icon, tooltip) => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("tray.create", { icon, tooltip });
+    isVisible.value = true;
+  };
+  const destroy = async () => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("tray.destroy");
+    isVisible.value = false;
+  };
+  const setIcon = async (icon) => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("tray.setIcon", { icon });
+  };
+  const setTooltip = async (tooltip) => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("tray.setTooltip", { tooltip });
+  };
+  const setMenu = async (menu) => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("tray.setMenu", { menu });
+  };
+  const setTitle = async (title) => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("tray.setTitle", { title });
+  };
+  return {
+    isVisible,
+    create,
+    destroy,
+    setIcon,
+    setTooltip,
+    setMenu,
+    setTitle
+  };
+}
+
+// src/composables/useNotification.ts
+function useNotification() {
+  const { craft, isReady } = useCraft();
+  const send = async (options) => {
+    if (!isReady.value || !craft.value) return;
+    await craft.value.invoke("notification.send", options);
+  };
+  const requestPermission = async () => {
+    if (!isReady.value || !craft.value) return false;
+    const result = await craft.value.requestPermission("notifications");
+    return result.granted;
+  };
+  return {
+    send,
+    requestPermission
+  };
+}
+
+// src/composables/useFileSystem.ts
+import { ref as ref3 } from "vue";
+function useFileSystem() {
+  const { craft, isReady } = useCraft();
+  const loading = ref3(false);
+  const error = ref3(null);
+  const readFile = async (path, encoding = "utf8") => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    try {
+      const result = await craft.value.invoke("fs.readFile", { path, encoding });
+      return result;
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const writeFile = async (path, data, encoding = "utf8") => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    try {
+      await craft.value.invoke("fs.writeFile", { path, data, encoding });
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const readDir = async (path) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    try {
+      const result = await craft.value.invoke("fs.readDir", { path });
+      return result;
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const mkdir = async (path, recursive = false) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    try {
+      await craft.value.invoke("fs.mkdir", { path, recursive });
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const remove = async (path, recursive = false) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    try {
+      await craft.value.invoke("fs.remove", { path, recursive });
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const exists = async (path) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    try {
+      const result = await craft.value.invoke("fs.exists", { path });
+      return result;
+    } catch (err) {
+      error.value = err;
+      return false;
+    }
+  };
+  const stat = async (path) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    try {
+      const result = await craft.value.invoke("fs.stat", { path });
+      return result;
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    readFile,
+    writeFile,
+    readDir,
+    mkdir,
+    remove,
+    exists,
+    stat,
+    loading,
+    error
+  };
+}
+
+// src/composables/useDatabase.ts
+import { ref as ref4 } from "vue";
+function useDatabase(dbPath) {
+  const { craft, isReady } = useCraft();
+  const loading = ref4(false);
+  const error = ref4(null);
+  const execute = async (sql, params = []) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    try {
+      const result = await craft.value.invoke("db.execute", { path: dbPath, sql, params });
+      return result;
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const query = async (sql, params = []) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    try {
+      const result = await craft.value.invoke("db.query", { path: dbPath, sql, params });
+      return result;
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const transaction = async (callback) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    try {
+      await craft.value.invoke("db.transaction.begin", { path: dbPath });
+      try {
+        await callback({
+          execute: async (sql, params = []) => {
+            return await craft.value.invoke("db.execute", { path: dbPath, sql, params });
+          }
+        });
+        await craft.value.invoke("db.transaction.commit", { path: dbPath });
+      } catch (err) {
+        await craft.value.invoke("db.transaction.rollback", { path: dbPath });
+        throw err;
+      }
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    execute,
+    query,
+    transaction,
+    loading,
+    error
+  };
+}
+
+// src/composables/useHttp.ts
+import { ref as ref5 } from "vue";
+function useHttp() {
+  const { craft, isReady } = useCraft();
+  const loading = ref5(false);
+  const error = ref5(null);
+  const fetch = async (url, options = {}) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    try {
+      const result = await craft.value.invoke("http.fetch", { url, ...options });
+      return result;
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const download = async (url, path, options = {}) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    if (options.onProgress) {
+      craft.value.on("download.progress", options.onProgress);
+    }
+    try {
+      await craft.value.invoke("http.download", { url, path });
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      if (options.onProgress) {
+        craft.value.off("download.progress", options.onProgress);
+      }
+      loading.value = false;
+    }
+  };
+  const upload = async (url, filePath, options = {}) => {
+    if (!isReady.value || !craft.value) throw new Error("Craft not ready");
+    loading.value = true;
+    error.value = null;
+    if (options.onProgress) {
+      craft.value.on("upload.progress", options.onProgress);
+    }
+    try {
+      const result = await craft.value.invoke("http.upload", { url, filePath, ...options });
+      return result;
+    } catch (err) {
+      error.value = err;
+      throw err;
+    } finally {
+      if (options.onProgress) {
+        craft.value.off("upload.progress", options.onProgress);
+      }
+      loading.value = false;
+    }
+  };
+  return {
+    fetch,
+    download,
+    upload,
+    loading,
+    error
+  };
+}
+
+// src/index.ts
+function useCraft() {
+  const craft = ref6(null);
+  const isReady = ref6(false);
+  onMounted(() => {
+    if (window.craft) {
+      craft.value = window.craft;
+      isReady.value = true;
+    } else {
+      const checkCraft = setInterval(() => {
+        if (window.craft) {
+          craft.value = window.craft;
+          isReady.value = true;
+          clearInterval(checkCraft);
+        }
+      }, 100);
+      onUnmounted(() => clearInterval(checkCraft));
+    }
+  });
+  return { craft, isReady };
+}
+function usePlatform() {
+  const { craft, isReady } = useCraft();
+  const platform = ref6(null);
+  const loading = ref6(true);
+  const error = ref6(null);
+  watch(isReady, async (ready) => {
+    if (ready && craft.value) {
+      try {
+        platform.value = await craft.value.getPlatform();
+      } catch (err) {
+        error.value = err;
+      } finally {
+        loading.value = false;
+      }
+    }
+  }, { immediate: true });
+  return { platform, loading, error };
+}
+function useDeviceInfo() {
+  const { craft, isReady } = useCraft();
+  const deviceInfo = ref6(null);
+  const loading = ref6(true);
+  const error = ref6(null);
+  watch(isReady, async (ready) => {
+    if (ready && craft.value) {
+      try {
+        deviceInfo.value = await craft.value.getDeviceInfo();
+      } catch (err) {
+        error.value = err;
+      } finally {
+        loading.value = false;
+      }
+    }
+  }, { immediate: true });
+  return { deviceInfo, loading, error };
+}
+function useToast() {
+  const { craft, isReady } = useCraft();
+  const showToast = async (message, duration = "short") => {
+    if (!isReady.value || !craft.value) {
+      console.warn("Craft not ready");
+      return;
+    }
+    await craft.value.showToast(message, duration);
+  };
+  return { showToast };
+}
+function useHaptic() {
+  const { craft, isReady } = useCraft();
+  const haptic = async (type = "selection") => {
+    if (!isReady.value || !craft.value) {
+      console.warn("Craft not ready");
+      return;
+    }
+    try {
+      await craft.value.haptic(type);
+    } catch (error) {
+      if (error?.code !== "CAPABILITY_DISABLED") throw error;
+    }
+  };
+  return { haptic };
+}
+function usePermission(permission) {
+  const { craft, isReady } = useCraft();
+  const granted = ref6(null);
+  const loading = ref6(false);
+  const error = ref6(null);
+  const request = async () => {
+    if (!isReady.value || !craft.value) {
+      console.warn("Craft not ready");
+      return;
+    }
+    loading.value = true;
+    try {
+      const result = await craft.value.requestPermission(permission);
+      granted.value = result.granted;
+    } catch (err) {
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return { granted, request, loading, error };
+}
+function useCraftEvent(event, callback) {
+  const { craft, isReady } = useCraft();
+  const unsubscribe = () => {
+    if (craft.value) {
+      craft.value.off(event, callback);
+    }
+  };
+  watch(isReady, (ready) => {
+    if (ready && craft.value) {
+      craft.value.on(event, callback);
+    }
+  }, { immediate: true });
+  onUnmounted(unsubscribe);
+  return { unsubscribe };
+}
+function useCraftInvoke() {
+  const { craft, isReady } = useCraft();
+  const invoke = async (method, params) => {
+    if (!isReady.value || !craft.value) {
+      throw new Error("Craft not ready");
+    }
+    return await craft.value.invoke(method, params);
+  };
+  return { invoke, isReady };
+}
+function useIsMobile() {
+  const { platform } = usePlatform();
+  const isMobile = computed(() => {
+    if (!platform.value) return false;
+    return platform.value.platform === "ios" || platform.value.platform === "android";
+  });
+  return isMobile;
+}
+function useIsDesktop() {
+  const { platform } = usePlatform();
+  const isDesktop = computed(() => {
+    if (!platform.value) return false;
+    return ["macos", "windows", "linux"].includes(platform.value.platform);
+  });
+  return isDesktop;
+}
+export {
+  useCraft,
+  useCraftEvent,
+  useCraftInvoke,
+  useDatabase,
+  useDeviceInfo,
+  useFileSystem,
+  useHaptic,
+  useHttp,
+  useIsDesktop,
+  useIsMobile,
+  useNotification,
+  usePermission,
+  usePlatform,
+  useToast,
+  useTray,
+  useWindow
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-native/vue",
-  "version": "0.0.91",
+  "version": "0.0.94",
   "homepage": "https://github.com/craft-native/craft/tree/main/packages/vue#readme",
   "repository": {
     "type": "git",
@@ -19,9 +19,9 @@
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.js"
     }
   },
   "scripts": {
@@ -42,7 +42,7 @@
     "vue": "^3.0.0"
   },
   "devDependencies": {
-    "vue": "^3.3.0",
+    "vue": "^3.5.43",
     "tsup": "^8.0.0",
     "typescript": "^7.0.2"
   }

package/LICENSE.md

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2025 Stacks.js
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.