@craft-native/vue 0.0.72

package/dist/index.js

@@ -0,0 +1,577 @@
+"use strict";
+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.ts
+var index_exports = {};
+__export(index_exports, {
+  useCraft: () => useCraft,
+  useCraftEvent: () => useCraftEvent,
+  useCraftInvoke: () => useCraftInvoke,
+  useDatabase: () => useDatabase,
+  useDeviceInfo: () => useDeviceInfo,
+  useFileSystem: () => useFileSystem,
+  useHaptic: () => useHaptic,
+  useHttp: () => useHttp,
+  useIsDesktop: () => useIsDesktop,
+  useIsMobile: () => useIsMobile,
+  useNotification: () => useNotification,
+  usePermission: () => usePermission,
+  usePlatform: () => usePlatform,
+  useToast: () => useToast,
+  useTray: () => useTray,
+  useWindow: () => useWindow
+});
+module.exports = __toCommonJS(index_exports);
+var import_vue6 = require("vue");
+
+// src/composables/useWindow.ts
+var import_vue = require("vue");
+function useWindow() {
+  const { craft, isReady } = useCraft();
+  const isFullscreen = (0, import_vue.ref)(false);
+  const isMaximized = (0, import_vue.ref)(false);
+  const isMinimized = (0, import_vue.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
+var import_vue2 = require("vue");
+function useTray() {
+  const { craft, isReady } = useCraft();
+  const isVisible = (0, import_vue2.ref)(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
+var import_vue3 = require("vue");
+function useFileSystem() {
+  const { craft, isReady } = useCraft();
+  const loading = (0, import_vue3.ref)(false);
+  const error = (0, import_vue3.ref)(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
+var import_vue4 = require("vue");
+function useDatabase(dbPath) {
+  const { craft, isReady } = useCraft();
+  const loading = (0, import_vue4.ref)(false);
+  const error = (0, import_vue4.ref)(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
+var import_vue5 = require("vue");
+function useHttp() {
+  const { craft, isReady } = useCraft();
+  const loading = (0, import_vue5.ref)(false);
+  const error = (0, import_vue5.ref)(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 = (0, import_vue6.ref)(null);
+  const isReady = (0, import_vue6.ref)(false);
+  (0, import_vue6.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);
+      (0, import_vue6.onUnmounted)(() => clearInterval(checkCraft));
+    }
+  });
+  return { craft, isReady };
+}
+function usePlatform() {
+  const { craft, isReady } = useCraft();
+  const platform = (0, import_vue6.ref)(null);
+  const loading = (0, import_vue6.ref)(true);
+  const error = (0, import_vue6.ref)(null);
+  (0, import_vue6.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 = (0, import_vue6.ref)(null);
+  const loading = (0, import_vue6.ref)(true);
+  const error = (0, import_vue6.ref)(null);
+  (0, import_vue6.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;
+    }
+    await craft.value.haptic(type);
+  };
+  return { haptic };
+}
+function usePermission(permission) {
+  const { craft, isReady } = useCraft();
+  const granted = (0, import_vue6.ref)(null);
+  const loading = (0, import_vue6.ref)(false);
+  const error = (0, import_vue6.ref)(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);
+    }
+  };
+  (0, import_vue6.watch)(isReady, (ready) => {
+    if (ready && craft.value) {
+      craft.value.on(event, callback);
+    }
+  }, { immediate: true });
+  (0, import_vue6.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 = (0, import_vue6.computed)(() => {
+    if (!platform.value) return false;
+    return platform.value.platform === "ios" || platform.value.platform === "android";
+  });
+  return isMobile;
+}
+function useIsDesktop() {
+  const { platform } = usePlatform();
+  const isDesktop = (0, import_vue6.computed)(() => {
+    if (!platform.value) return false;
+    return ["macos", "windows", "linux"].includes(platform.value.platform);
+  });
+  return isDesktop;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCraft,
+  useCraftEvent,
+  useCraftInvoke,
+  useDatabase,
+  useDeviceInfo,
+  useFileSystem,
+  useHaptic,
+  useHttp,
+  useIsDesktop,
+  useIsMobile,
+  useNotification,
+  usePermission,
+  usePlatform,
+  useToast,
+  useTray,
+  useWindow
+});