@spitx/helper 0.0.0

package/error/index.d.ts

@@ -0,0 +1,4 @@
+export type ErrorHandlerResult<T> = Promise<[Error, null] | [null, T]>;
+export declare function handleError<T>(p: Promise<T>): ErrorHandlerResult<T>;
+export type ErrorHandlerResultSync<T> = [Error, null] | [null, T];
+export declare function handleErrorSync<T extends (...args: any[]) => any>(callback: T): ErrorHandlerResultSync<ReturnType<T>>;

package/flat/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 拍平嵌套数组
+ * @param cb 处理每一个节点，如果需要继续处理子节点，返回一个子节点数组
+ */
+export declare function flat<T>(data: T[], cb: (v: T) => T[]): void;

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from './error/index.ts';
+export * from './flat/index.ts';
+export * from './onlyLast/index.ts';
+export * from './promise/index.ts';
+export * from './request/index.ts';
+export * from './string/index.ts';

package/main.js

@@ -0,0 +1,82 @@
+function d(e) {
+  let n;
+  const r = new Promise((t) => {
+    n = t;
+  });
+  return e.then((t) => {
+    n([null, t]);
+  }).catch((t) => {
+    n([t, null]);
+  }), r;
+}
+function y(e) {
+  try {
+    return [null, e()];
+  } catch (n) {
+    return [n, null];
+  }
+}
+function g(e, n) {
+  const r = [...e];
+  let t;
+  for (; r.length && (t = r.shift(), !!t); ) {
+    const o = n(t);
+    Array.isArray(o) && r.unshift(...o);
+  }
+}
+function a() {
+  let e;
+  return async function(n) {
+    const r = e = Math.random() * 1e7;
+    return {
+      data: await n,
+      isLast: r === e
+    };
+  };
+}
+function h(e = () => {
+}) {
+  let n = () => {
+  }, r = () => {
+  };
+  return {
+    promise: new Promise((o, s) => {
+      e(o, s), n = o, r = s;
+    }),
+    resolve: n,
+    reject: r
+  };
+}
+function w(e) {
+  return new Promise((n) => {
+    setTimeout(n, e);
+  });
+}
+const i = /* @__PURE__ */ new WeakMap();
+async function p(e, n) {
+  const { least: r, signal: t = new AbortController() } = n;
+  i.has(t) || i.set(t, a());
+  const o = i.get(t) || a(), [s] = await Promise.all([o(e), w(r)]);
+  return s;
+}
+async function P(e, n) {
+  const {
+    delay: r,
+    signal: t = new AbortController(),
+    onSlow: o
+  } = n;
+  i.has(t) || i.set(t, a());
+  const s = i.get(t) || a(), { promise: u, resolve: f } = h(), l = Date.now();
+  setTimeout(() => f(l), r);
+  const c = s(e);
+  return await Promise.race([c, u]) === l && o(), c;
+}
+export {
+  g as flat,
+  d as handleError,
+  y as handleErrorSync,
+  a as onlyLast,
+  p as withMinLoading,
+  h as withPromiseResolver,
+  P as withSlowLoading
+};

package/main.umd.cjs

@@ -0,0 +1 @@
+(function(r,a){typeof exports=="object"&&typeof module<"u"?a(exports):typeof define=="function"&&define.amd?define(["exports"],a):(r=typeof globalThis<"u"?globalThis:r||self,a(r.main={}))})(this,function(r){"use strict";function a(t){let n;const o=new Promise(e=>{n=e});return t.then(e=>{n([null,e])}).catch(e=>{n([e,null])}),o}function h(t){try{return[null,t()]}catch(n){return[n,null]}}function w(t,n){const o=[...t];let e;for(;o.length&&(e=o.shift(),!!e);){const i=n(e);Array.isArray(i)&&o.unshift(...i)}}function c(){let t;return async function(n){const o=t=Math.random()*1e7;return{data:await n,isLast:o===t}}}function u(t=()=>{}){let n=()=>{},o=()=>{};return{promise:new Promise((i,l)=>{t(i,l),n=i,o=l}),resolve:n,reject:o}}function m(t){return new Promise(n=>{setTimeout(n,t)})}const s=new WeakMap;async function y(t,n){const{least:o,signal:e=new AbortController}=n;s.has(e)||s.set(e,c());const i=s.get(e)||c(),[l]=await Promise.all([i(t),m(o)]);return l}async function g(t,n){const{delay:o,signal:e=new AbortController,onSlow:i}=n;s.has(e)||s.set(e,c());const l=s.get(e)||c(),{promise:P,resolve:p}=u(),f=Date.now();setTimeout(()=>p(f),o);const d=l(t);return await Promise.race([d,P])===f&&i(),d}r.flat=w,r.handleError=a,r.handleErrorSync=h,r.onlyLast=c,r.withMinLoading=y,r.withPromiseResolver=u,r.withSlowLoading=g,Object.defineProperty(r,Symbol.toStringTag,{value:"Module"})});

package/onlyLast/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 并发竞态，保留最后一次执行的结果
+ * @example
+ * const controller = onlyLast()
+ * const {data: promiseResult, isLast: boolean} = await controller(promise)
+ */
+export declare function onlyLast(): <T>(P: T) => Promise<{
+    data: Awaited<T>;
+    isLast: boolean;
+}>;

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@spitx/helper",
+  "type": "module",
+  "version": "0.0.0",
+  "description": "helper module",
+  "author": "",
+  "license": "ISC",
+  "keywords": [],
+  "exports": {
+    ".": "./main.js"
+  },
+  "main": "./main.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "vite build"
+  },
+  "dependencies": {}
+}

package/promise/index.d.ts

@@ -0,0 +1,7 @@
+type Resolver<T> = (value: T | PromiseLike<T>) => void;
+export declare function withPromiseResolver<T>(cb?: (resolve: Resolver<T>, reject: Resolver<T>) => void): {
+    promise: Promise<T>;
+    resolve: Resolver<T>;
+    reject: Resolver<T>;
+};
+export {};

package/request/index.d.ts

@@ -0,0 +1 @@
+export { withMinLoading, withSlowLoading, } from './loading';

package/request/loading.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 对Promise做如下处理
+ * - 对请求都保持至少delay时长的loading
+ * - 处理竞态请求
+ * @param {AbortController} option.signal 用于标识竞态请求
+ * @example
+ * const signal = new AbortController()
+ * const { data, isLast} = leastLoading(request, {
+ *  delay: 200,
+ *  signal: signal,
+ * })
+ * if (!isLast) return
+ * doSomething(data)
+ */
+export declare function withMinLoading<T>(p: Promise<T>, option: {
+    least: number;
+    signal?: AbortController;
+}): Promise<{
+    data: Awaited<T>;
+    isLast: boolean;
+}>;
+/**
+ * 对 Promise 做如下处理
+ * - 请求时长 < delay 时，不做任何处理
+ * - 请求时长 > delay 且 为竞态请求的最后一个时，触发最后一个请求的onSlow函数
+ * - 处理竞态请求
+ * @param {AbortController} option.signal 用于标识竞态请求
+ * @example
+ * const signal = new AbortController()
+ * const loading = ref(false)
+ * const { data, isLast} = slowLoading(request, {
+ *  delay: 200,
+ *  signal: signal,
+ *  onSlow: () => {
+ *    loading.value = true
+ *  }
+ * })
+ * if (!isLast) return
+ * doSomething(data)
+ */
+export declare function withSlowLoading<T>(p: Promise<T>, option: {
+    delay: number;
+    signal?: AbortController;
+    onSlow: () => void;
+}): Promise<{
+    data: Awaited<T>;
+    isLast: boolean;
+}>;

package/service/index.d.ts

@@ -0,0 +1,16 @@
+import { AxiosResponse, CreateAxiosDefaults, InternalAxiosRequestConfig } from 'axios';
+import { ErrorHandlerResult } from '../error';
+declare function createApiInstance(options?: CreateAxiosDefaults, callbacks?: {
+    onNotFound?: () => void;
+    onServiceFaild?: () => void;
+    onUnauthorized?: () => void;
+    beforeRequest?: (config: InternalAxiosRequestConfig<any>) => void;
+    beforeResponse?: (response: AxiosResponse<any, any>) => void;
+}): {
+    instance: import('axios').AxiosInstance;
+    get<T>(url: string, config?: import('axios').AxiosRequestConfig<unknown> | undefined): ErrorHandlerResult<T>;
+    post<T>(url: string, data?: unknown, config?: import('axios').AxiosRequestConfig<unknown> | undefined): ErrorHandlerResult<T>;
+    delete<T>(url: string, config?: import('axios').AxiosRequestConfig<unknown> | undefined): ErrorHandlerResult<T>;
+    put<T>(url: string, data?: unknown, config?: import('axios').AxiosRequestConfig<unknown> | undefined): ErrorHandlerResult<T>;
+};
+export default createApiInstance;

package/string/index.d.ts

@@ -0,0 +1 @@
+export default function randomString(len?: number): string;

package/useLoadingDelay/index.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+export default function useLoadingDelay(fn: (...arg: unknown[]) => Promise<any>, options?: {
+    loading?: Ref<boolean>;
+    loadingDelay?: number;
+}): Promise<{
+    loading: Ref<boolean, boolean>;
+    data: [Error, null] | [null, any];
+}>;