@stacksjs/utils 0.39.0 → 0.40.0

package/dist/base.d.ts

@@ -0,0 +1 @@
+export declare const toString: (v: any) => any;

package/dist/base.mjs

@@ -0,0 +1 @@
+export const toString = (v) => Object.prototype.toString.call(v);

package/dist/function.d.ts

@@ -0,0 +1,18 @@
+import type { Fn, Nullable } from '@stacksjs/types';
+/**
+ * Call every function in an array
+ */
+export declare function batchInvoke(functions: Nullable<Fn>[]): void;
+/**
+ * Pass the value through the callback, and return the value
+ *
+ * @example
+ * ```
+ * function createUser(name: string): User {
+ *   return tap(new User, user => {
+ *     user.name = name
+ *   })
+ * }
+ * ```
+ */
+export declare function tap<T>(value: T, callback: (value: T) => void): T;

package/dist/function.mjs

@@ -0,0 +1,7 @@
+export function batchInvoke(functions) {
+  functions.forEach((fn) => fn && fn());
+}
+export function tap(value, callback) {
+  callback(value);
+  return value;
+}

package/dist/guards.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Type guard to filter out null-ish values
+ *
+ * @category Guards
+ * @example array.filter(notNullish)
+ */
+export declare function notNullish<T>(v: T | null | undefined): v is NonNullable<T>;
+/**
+ * Type guard to filter out null values
+ *
+ * @category Guards
+ * @example array.filter(noNull)
+ */
+export declare function noNull<T>(v: T | null): v is Exclude<T, null>;
+/**
+ * Type guard to filter out null-ish values
+ *
+ * @category Guards
+ * @example array.filter(notUndefined)
+ */
+export declare function notUndefined<T>(v: T): v is Exclude<T, undefined>;
+/**
+ * Type guard to filter out falsy values
+ *
+ * @category Guards
+ * @example array.filter(isTruthy)
+ */
+export declare function isTruthy<T>(v: T): v is NonNullable<T>;

package/dist/guards.mjs

@@ -0,0 +1,12 @@
+export function notNullish(v) {
+  return v != null;
+}
+export function noNull(v) {
+  return v !== null;
+}
+export function notUndefined(v) {
+  return v !== void 0;
+}
+export function isTruthy(v) {
+  return Boolean(v);
+}

package/dist/index.d.ts

@@ -1,4 +1,11 @@
+export * from './base';
 export * from './helpers';
+export * from './promise';
+export * from './function';
+export * from './guards';
+export * from './is';
+export * from './p';
+export * from './vendor';
 export * from '@vueuse/core';
 export * from '@vueuse/math';
 export * from '@vueuse/head';

package/dist/index.mjs

@@ -1,4 +1,11 @@
+export * from "./base.mjs";
 export * from "./helpers.mjs";
+export * from "./promise.mjs";
+export * from "./function.mjs";
+export * from "./guards.mjs";
+export * from "./is.mjs";
+export * from "./p.mjs";
+export * from "./vendor.mjs";
 export * from "@vueuse/core";
 export * from "@vueuse/math";
 export * from "@vueuse/head";

package/dist/is.d.ts

@@ -0,0 +1 @@
+export declare const isBrowser: boolean;

package/dist/is.mjs

@@ -0,0 +1 @@
+export const isBrowser = typeof window !== "undefined";

package/dist/p.d.ts

@@ -0,0 +1,41 @@
+interface POptions {
+    /**
+     * How many promises are resolved at the same time.
+     */
+    concurrency?: number | undefined;
+}
+declare class PInstance<T = any> extends Promise<Awaited<T>[]> {
+    items: Iterable<T>;
+    options?: POptions | undefined;
+    private promises;
+    get promise(): Promise<Awaited<T>[]>;
+    constructor(items?: Iterable<T>, options?: POptions | undefined);
+    add(...args: (T | Promise<T>)[]): void;
+    map<U>(fn: (value: Awaited<T>, index: number) => U): PInstance<Promise<U>>;
+    filter(fn: (value: Awaited<T>, index: number) => boolean | Promise<boolean>): PInstance<Promise<T>>;
+    forEach(fn: (value: Awaited<T>, index: number) => void): Promise<void>;
+    reduce<U>(fn: (previousValue: U, currentValue: Awaited<T>, currentIndex: number, array: Awaited<T>[]) => U, initialValue: U): Promise<U>;
+    clear(): void;
+    then(fn?: () => PromiseLike<any>): Promise<any>;
+    catch(fn?: (err: unknown) => PromiseLike<any>): Promise<any>;
+    finally(fn?: () => void): Promise<Awaited<T>[]>;
+}
+/**
+ * Utility for managing multiple promises.
+ *
+ * @see https://github.com/antfu/utils/tree/main/docs/p.md
+ * @category Promise
+ * @example
+ * ```
+ * import { p } from '@antfu/utils'
+ *
+ * const items = [1, 2, 3, 4, 5]
+ *
+ * await p(items)
+ *   .map(async i => await multiply(i, 3))
+ *   .filter(async i => await isEven(i))
+ * // [6, 12]
+ * ```
+ */
+export declare function p<T = any>(items?: Iterable<T>, options?: POptions): PInstance<T>;
+export {};

package/dist/p.mjs

@@ -0,0 +1,75 @@
+import pLimit from "p-limit";
+const VOID = Symbol("p-void");
+class PInstance extends Promise {
+  constructor(items = [], options) {
+    super(() => {
+    });
+    this.items = items;
+    this.options = options;
+    this.promises = /* @__PURE__ */ new Set();
+  }
+  get promise() {
+    let batch;
+    const items = [...Array.from(this.items), ...Array.from(this.promises)];
+    if (this.options?.concurrency) {
+      const limit = pLimit(this.options.concurrency);
+      batch = Promise.all(items.map((p2) => limit(() => p2)));
+    } else {
+      batch = Promise.all(items);
+    }
+    return batch.then((l) => l.filter((i) => i !== VOID));
+  }
+  add(...args) {
+    args.forEach((i) => {
+      this.promises.add(i);
+    });
+  }
+  map(fn) {
+    return new PInstance(
+      Array.from(this.items).map(async (i, idx) => {
+        const v = await i;
+        if (v === VOID)
+          return VOID;
+        return fn(v, idx);
+      }),
+      this.options
+    );
+  }
+  filter(fn) {
+    return new PInstance(
+      Array.from(this.items).map(async (i, idx) => {
+        const v = await i;
+        const r = await fn(v, idx);
+        if (!r)
+          return VOID;
+        return v;
+      }),
+      this.options
+    );
+  }
+  forEach(fn) {
+    return this.map(fn).then();
+  }
+  reduce(fn, initialValue) {
+    return this.promise.then((array) => array.reduce(fn, initialValue));
+  }
+  clear() {
+    this.promises.clear();
+  }
+  then(fn) {
+    const p2 = this.promise;
+    if (fn)
+      return p2.then(fn);
+    else
+      return p2;
+  }
+  catch(fn) {
+    return this.promise.catch(fn);
+  }
+  finally(fn) {
+    return this.promise.finally(fn);
+  }
+}
+export function p(items, options) {
+  return new PInstance(items, options);
+}

package/dist/promise.d.ts

@@ -0,0 +1,51 @@
+import type { Fn } from '@stacksjs/types';
+/**
+ * Promised `setTimeout`
+ *
+ * @category Promise
+ */
+export declare function sleep(ms: number, callback?: Fn<any>): Promise<void>;
+/**
+ * Create a promise lock
+ *
+ * @category Promise
+ * @example
+ * ```
+ * const lock = createPromiseLock()
+ *
+ * lock.run(async () => {
+ *   await doSomething()
+ * })
+ *
+ * // in anther context:
+ * await lock.wait() // it will wait all tasking finished
+ * ```
+ */
+export declare function createPromiseLock(): {
+    run<T = void>(fn: () => Promise<T>): Promise<T>;
+    wait(): Promise<void>;
+    isWaiting(): boolean;
+    clear(): void;
+};
+/**
+ * Promise with `resolve` and `reject` methods of itself
+ */
+export interface ControlledPromise<T = void> extends Promise<T> {
+    resolve(value: T | PromiseLike<T>): void;
+    reject(reason?: any): void;
+}
+/**
+ * Return a Promise with `resolve` and `reject` methods
+ *
+ * @category Promise
+ * @example
+ * ```
+ * const promise = createControlledPromise()
+ *
+ * await promise
+ *
+ * // in anther context:
+ * promise.resolve(data)
+ * ```
+ */
+export declare function createControlledPromise<T>(): ControlledPromise<T>;

package/dist/promise.mjs

@@ -0,0 +1,42 @@
+import { remove } from "@stacksjs/arrays";
+export function sleep(ms, callback) {
+  return new Promise(
+    (resolve) => setTimeout(async () => {
+      await callback?.();
+      resolve();
+    }, ms)
+  );
+}
+export function createPromiseLock() {
+  const locks = [];
+  return {
+    async run(fn) {
+      const p = fn();
+      locks.push(p);
+      try {
+        return await p;
+      } finally {
+        remove(locks, p);
+      }
+    },
+    async wait() {
+      await Promise.allSettled(locks);
+    },
+    isWaiting() {
+      return Boolean(locks.length);
+    },
+    clear() {
+      locks.length = 0;
+    }
+  };
+}
+export function createControlledPromise() {
+  let resolve, reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  promise.resolve = resolve;
+  promise.reject = reject;
+  return promise;
+}

package/dist/vendor.d.ts

@@ -0,0 +1 @@
+export { throttle, debounce } from 'throttle-debounce';

package/dist/vendor.mjs

@@ -0,0 +1 @@
+export { throttle, debounce } from "throttle-debounce";

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@stacksjs/utils",
   "type": "module",
-  "version": "0.39.0",
-  "packageManager": "pnpm@7.15.0",
+  "version": "0.40.0",
+  "packageManager": "pnpm@7.16.0",
   "description": "The Stacks helper functions.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -38,17 +38,17 @@
   ],
   "engines": {
     "node": ">=v18.12.1",
-    "pnpm": ">=7.15.0"
+    "pnpm": ">=7.16.0"
   },
   "peerDependencies": {
-    "@stacksjs/cli": "0.39.0",
-    "@stacksjs/config": "0.39.0",
-    "@stacksjs/lint": "0.39.0",
-    "@stacksjs/path": "0.39.0",
-    "@stacksjs/storage": "0.39.0",
-    "@stacksjs/types": "0.39.0",
+    "@stacksjs/cli": "0.40.0",
+    "@stacksjs/config": "0.40.0",
+    "@stacksjs/lint": "0.40.0",
+    "@stacksjs/path": "0.40.0",
+    "@stacksjs/storage": "0.40.0",
+    "@stacksjs/types": "0.40.0",
     "@vueuse/core": "^9.5.0",
-    "@vueuse/head": "^0.9.8",
+    "@vueuse/head": "^1.0.12",
     "@vueuse/math": "^9.5.0",
     "@vueuse/shared": "^9.5.0",
     "defu": "^6.1.0",
@@ -57,7 +57,9 @@
     "esno": "^0.16.3",
     "fast-glob": "^3.2.12",
     "kolorist": "1.6.0",
-    "rimraf": "^3.0.2"
+    "p-limit": "^4.0.0",
+    "rimraf": "^3.0.2",
+    "throttle-debounce": "^5.0.0"
   },
   "devDependencies": {
     "mkdist": "^0.4.0",