@vrojs/use 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,65 @@
+import * as vue from 'vue';
+import { Ref } from 'vue';
+
+type AnyPromiseFn = (...args: any[]) => Promise<any>;
+interface UseAsyncTaskOptions<T extends AnyPromiseFn> {
+    /**
+     * 是否立即执行 onBeforeMount 执行，默认 false
+     */
+    immediate?: boolean;
+    /**
+     * 是否在 onActivated 执行，默认 false
+     */
+    activated?: boolean;
+    /**
+     * 立即执行的时候 第一次需要传递的参数
+     */
+    initialParams?: Parameters<T> | (() => Parameters<T>);
+    /**
+     * 初始数据
+     */
+    initialValue?: Awaited<ReturnType<T>>;
+    /**
+     * 捕获了异常，是否继续抛出，默认 false
+     */
+    throwError?: boolean | (() => boolean);
+    /**
+     * 错误回调，返回 false 或者 undefined 的时候，阻断默认错误 error 逻辑
+     */
+    onError?: (err: unknown) => boolean | undefined | Promise<boolean | undefined>;
+}
+interface UseAsyncTaskResult<T, D> {
+    data: Ref<D>;
+    error: Ref<unknown>;
+    loading: Ref<boolean>;
+    trigger: T;
+}
+/**
+ * 异步任务执行
+ */
+declare function useAsyncTask<T extends AnyPromiseFn>(task: T, options: UseAsyncTaskOptions<T> & Required<Pick<UseAsyncTaskOptions<T>, 'initialValue'>>): UseAsyncTaskResult<T, Awaited<ReturnType<T>>>;
+declare function useAsyncTask<T extends AnyPromiseFn>(task: T, options?: UseAsyncTaskOptions<T>): UseAsyncTaskResult<T, Awaited<ReturnType<T>> | undefined>;
+
+declare function useComposition(): {
+    handleCompositionStart: (event: CompositionEvent) => void;
+    handleCompositionEnd: (event: CompositionEvent) => void;
+};
+
+declare function useId(): string;
+
+interface UseVisibleOptions<T extends Record<string, any>, P = any> {
+    showCallback?: (options?: T) => void | Promise<void>;
+    hideCallback?: (reason: any) => void | Promise<void>;
+    confirmCallback?: (...args: any[]) => P | Promise<P>;
+}
+interface UseVisibleShowOptions {
+    beforeClose?: (action: 'cancel' | 'confirm', ...args: any[]) => boolean | Promise<boolean>;
+}
+declare function useVisible<T extends Record<string, any>, R = any>(options?: UseVisibleOptions<T, R>): {
+    visible: vue.Ref<boolean, boolean>;
+    show: <P = R>(options?: UseVisibleShowOptions & T) => Promise<P>;
+    confirm: (...args: any[]) => Promise<void>;
+    hide: (reason?: any) => Promise<void>;
+};
+
+export { type UseAsyncTaskOptions, type UseAsyncTaskResult, type UseVisibleOptions, type UseVisibleShowOptions, useAsyncTask, useComposition, useId, useVisible };

package/dist/index.js

@@ -0,0 +1,148 @@
+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());
+  });
+};
+
+// src/useAsyncTask/index.ts
+import { isFunction } from "@daysnap/utils";
+import { onActivated, onBeforeMount, ref } from "vue";
+function useAsyncTask(task, options) {
+  const { initialValue, immediate, activated, throwError, onError, initialParams } = options != null ? options : {};
+  const data = ref(initialValue);
+  const error = ref();
+  const loading = ref(false);
+  const trigger = (...args) => __async(null, null, function* () {
+    var _a;
+    try {
+      error.value = void 0;
+      loading.value = true;
+      data.value = yield task(...args);
+      return data.value;
+    } catch (err) {
+      if ((_a = yield onError == null ? void 0 : onError(err)) != null ? _a : true) {
+        error.value = err;
+        const isThrow = isFunction(throwError) ? throwError() : throwError;
+        if (isThrow) {
+          throw err;
+        }
+      }
+    } finally {
+      loading.value = false;
+    }
+  });
+  const init = () => __async(null, null, function* () {
+    const args = isFunction(initialParams) ? initialParams() : initialParams != null ? initialParams : [];
+    yield trigger(...args);
+  });
+  onBeforeMount(() => __async(null, null, function* () {
+    if (immediate) {
+      yield init();
+    }
+  }));
+  onActivated(() => __async(null, null, function* () {
+    if (activated) {
+      yield init();
+    }
+  }));
+  return {
+    data,
+    error,
+    loading,
+    trigger
+  };
+}
+
+// src/useComposition/index.ts
+function useComposition() {
+  const handleCompositionStart = (event) => {
+    ;
+    event.target.composing = true;
+  };
+  const handleCompositionEnd = (event) => {
+    var _a;
+    ;
+    event.target.composing = false;
+    (_a = event.target) == null ? void 0 : _a.dispatchEvent(new Event("input", { bubbles: true }));
+  };
+  return {
+    handleCompositionStart,
+    handleCompositionEnd
+  };
+}
+
+// src/useId/index.ts
+import { getCurrentInstance } from "vue";
+var current = 0;
+function useId() {
+  const vm = getCurrentInstance();
+  const name = typeof (vm == null ? void 0 : vm.type) === "object" ? vm.type.name || "unknown" : "unknown";
+  return `${name}-${++current}`;
+}
+
+// src/useVisible/index.ts
+import { ref as ref2 } from "vue";
+function useVisible(options = {}) {
+  const { showCallback, hideCallback, confirmCallback } = options;
+  const visible = ref2(false);
+  let resolve;
+  let reject;
+  let beforeClose;
+  const show = (options2) => __async(null, null, function* () {
+    beforeClose = options2 == null ? void 0 : options2.beforeClose;
+    yield showCallback == null ? void 0 : showCallback(options2);
+    return new Promise((_resolve, _reject) => {
+      resolve = _resolve;
+      reject = _reject;
+      visible.value = true;
+    });
+  });
+  const hide = (reason) => __async(null, null, function* () {
+    var _a;
+    const result = (_a = yield beforeClose == null ? void 0 : beforeClose("cancel", reason)) != null ? _a : true;
+    if (!result) {
+      return;
+    }
+    yield hideCallback == null ? void 0 : hideCallback(reason);
+    reject == null ? void 0 : reject(reason || "cancel");
+    visible.value = false;
+  });
+  const confirm = (...args) => __async(null, null, function* () {
+    var _a;
+    const result = (_a = yield beforeClose == null ? void 0 : beforeClose("confirm", ...args)) != null ? _a : true;
+    if (!result) {
+      return;
+    }
+    const value = confirmCallback ? yield confirmCallback(...args) : args[0];
+    reject = null;
+    resolve == null ? void 0 : resolve(value);
+    visible.value = false;
+  });
+  return {
+    visible,
+    show,
+    confirm,
+    hide
+  };
+}
+export {
+  useAsyncTask,
+  useComposition,
+  useId,
+  useVisible
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@vrojs/use",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "vrojs composables",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "vro",
+    "vrojs",
+    "composables",
+    "vue"
+  ],
+  "author": "woshiajuana",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "@daysnap/utils": ">=0.1.34",
+    "vue": ">=3.0.0",
+    "vue-router": ">=4.2.4"
+  },
+  "devDependencies": {
+    "@daysnap/utils": "^0.1.34",
+    "rimraf": "^6.0.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vue": "^3.5.22"
+  },
+  "scripts": {
+    "build": "npm run clean && tsup",
+    "clean": "rimraf ./dist",
+    "release": "npm run build && dsc publish --pnpm",
+    "sync": "dsc sync"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  }
+}