@aiszlab/relax 1.2.57 → 1.2.58

package/dist/is/is-refable.js

@@ -0,0 +1,34 @@
+import { isValidElement } from 'react';
+import { isFragment, isMemo } from 'react-is';
+
+/**
+ * @description
+ */
+var isRefable = function isRefable(node) {
+  if (!isValidElement(node)) {
+    return false;
+  }
+  if (isFragment(node)) {
+    return false;
+  }
+  return _RefableElement(node);
+};
+/**
+ * @description
+ * refable element
+ */
+var _RefableElement = function _RefableElement(element) {
+  var _type$prototype, _element$prototype;
+  var type = isMemo(element) ? element.type.type : element.type;
+  // Function component node
+  if (typeof type === "function" && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render)) {
+    return false;
+  }
+  // Class component
+  if (typeof element === "function" && !((_element$prototype = element.prototype) !== null && _element$prototype !== void 0 && _element$prototype.render)) {
+    return false;
+  }
+  return true;
+};
+
+export { isRefable };

package/dist/is/is-set.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * is set
+ */
+export declare const isSet: (value: unknown) => value is Set<unknown>;

package/dist/is/is-set.js

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * is set
+ */
+var isSet = function isSet(value) {
+  return value instanceof Set;
+};
+
+export { isSet };

package/dist/is/is-state-getter.d.ts

@@ -0,0 +1,6 @@
+import type { State, StateGetter } from "../types";
+/**
+ * @description
+ * is state getter
+ */
+export declare const isStateGetter: <T>(state: State<T>) => state is StateGetter<T>;

package/dist/is/is-state-getter.js

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * is state getter
+ */
+var isStateGetter = function isStateGetter(state) {
+  return typeof state === "function";
+};
+
+export { isStateGetter };

package/dist/is/is-style-element.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * style element
+ */
+export declare const isStyleElement: (element: Element) => element is HTMLStyleElement;

package/dist/is/is-style-element.js

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * style element
+ */
+var isStyleElement = function isStyleElement(element) {
+  return element.tagName === "STYLE";
+};
+
+export { isStyleElement };

package/dist/is/is-thenable.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * is thenable
+ */
+export declare const isThenable: <T>(value: T | PromiseLike<T>) => value is PromiseLike<T>;

package/dist/is/is-thenable.js

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * is thenable
+ */
+var isThenable = function isThenable(value) {
+  return value instanceof Promise || !!(value !== null && value !== void 0 && value.then);
+};
+
+export { isThenable };

package/dist/is/is-undefined.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * is undefined
+ */
+export declare const isUndefined: (value: unknown) => value is undefined;

package/dist/is/is-undefined.js

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * is undefined
+ */
+var isUndefined = function isUndefined(value) {
+  return value === void 0;
+};
+
+export { isUndefined };

package/dist/is/is-void.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * is null or undefined
+ */
+export declare const isVoid: (value: unknown) => value is null | undefined;

package/dist/is/is-void.js

@@ -0,0 +1,12 @@
+import { isUndefined } from './is-undefined.js';
+import { isNull } from './is-null.js';
+
+/**
+ * @description
+ * is null or undefined
+ */
+var isVoid = function isVoid(value) {
+  return isNull(value) || isUndefined(value);
+};
+
+export { isVoid };

package/dist/types/first.d.ts

@@ -0,0 +1 @@
+export type First<T> = T extends [infer D, ...Array<unknown>] ? D : undefined;

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export type { Nullable } from "./nullable";
+export type { Partialable } from "./partialable";
+export type { Voidable } from "./voidable";
+export type { RequiredIn } from "./required-in";
+export type { ThenableEffectCallback } from "./thenable-effect-callback";
+export type { First } from "./first";
+export type { Last } from "./last";
+export type { State, StateGetter } from "./state";

package/dist/types/last.d.ts

@@ -0,0 +1 @@
+export type Last<T> = T extends [...Array<unknown>, infer D] ? D : undefined;

package/dist/types/nullable.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * null able
+ */
+export type Nullable<T> = T | null;

package/dist/types/partialable.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * partial able
+ */
+export type Partialable<T> = T | undefined;

package/dist/types/required-in.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * require some fields
+ */
+export type RequiredIn<T, K extends keyof T> = Required<Pick<T, K>> & Omit<T, K>;

package/dist/types/state.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @description
+ * in react, define some initial state always use a value getter
+ */
+export type StateGetter<T> = () => T;
+/**
+ * @description
+ * value or state setter
+ */
+export type State<T> = T | StateGetter<T>;

package/dist/types/thenable-effect-callback.d.ts

@@ -0,0 +1,6 @@
+import type { EffectCallback } from "react";
+/**
+ * @description
+ * thenable effect callback
+ */
+export type ThenableEffectCallback = () => ReturnType<EffectCallback> | PromiseLike<ReturnType<EffectCallback>>;

package/dist/types/voidable.d.ts

@@ -0,0 +1,7 @@
+import type { Partialable } from "./partialable";
+import type { Nullable } from "./nullable";
+/**
+ * @description
+ * void able
+ */
+export type Voidable<T> = Partialable<Nullable<T>>;

package/dist/utils/chain.d.ts

@@ -0,0 +1,2 @@
+import type { Voidable } from "../types";
+export declare const chain: <T extends Function>(...callbacks: Voidable<T>[]) => T;

package/dist/utils/chain.js

@@ -0,0 +1,15 @@
+var chain = function chain() {
+  for (var _len = arguments.length, callbacks = new Array(_len), _key = 0; _key < _len; _key++) {
+    callbacks[_key] = arguments[_key];
+  }
+  return function () {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    callbacks.forEach(function (callback) {
+      callback === null || callback === void 0 || callback.apply(void 0, args);
+    });
+  };
+};
+
+export { chain };

package/dist/utils/clamp.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * get mid value
+ * @param value number
+ * @param min number
+ * @param max number
+ * @returns number
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;

package/dist/utils/clamp.js

@@ -0,0 +1,13 @@
+/**
+ * @description
+ * get mid value
+ * @param value number
+ * @param min number
+ * @param max number
+ * @returns number
+ */
+var clamp = function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+};
+
+export { clamp };

package/dist/utils/clone.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @description
+ * in develop, there are many cases to clone a string/number/object/array
+ * this util is planning to resolve it
+ */
+export declare const clone: (value: unknown) => any;

package/dist/utils/clone.js

@@ -0,0 +1,17 @@
+import { isArray } from '../is/is-array.js';
+import { isPrimitive } from '../is/is-primitive.js';
+
+/**
+ * @description
+ * in develop, there are many cases to clone a string/number/object/array
+ * this util is planning to resolve it
+ */
+var clone = function clone(value) {
+  if (isPrimitive(value)) return value;
+  if (value instanceof Map) return new Map(value);
+  if (value instanceof Set) return new Set(value);
+  if (isArray(value)) return Array.from(value);
+  return Object(value);
+};
+
+export { clone };

package/dist/utils/debounce.d.ts

@@ -0,0 +1,23 @@
+import { type Callable } from "../hooks/use-event";
+export interface Debounced<T extends Callable> {
+    /**
+     * @description
+     * value trigger
+     */
+    next: (...args: Parameters<T>) => void;
+    /**
+     * @description
+     * complete current debounce/throttle function
+     */
+    flush: () => void;
+    /**
+     * @description
+     * ignore any value after call cancel
+     */
+    abort: () => void;
+}
+export type Debouncer<T extends Callable, R extends Array<unknown> = Parameters<T>> = {
+    callback: (...args: R) => ReturnType<T>;
+    pipe: (...args: Parameters<T>) => R | Promise<R>;
+};
+export declare const debounce: <T extends Callable, R extends Array<unknown> = Parameters<T>>(debouncer: Debouncer<T, R> | T, wait: number) => Debounced<T>;

package/dist/utils/debounce.js

@@ -0,0 +1,32 @@
+import { debounceTime } from 'rxjs';
+import { isFunction } from '../is/is-function.js';
+import { Waitable } from './waitable.js';
+
+var debounce = function debounce(debouncer, wait) {
+  var isCallable = isFunction(debouncer);
+  var callback = isCallable ? debouncer : debouncer.callback;
+  var pipe = isCallable ? function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return args;
+  } : debouncer.pipe;
+  var waiter = new Waitable({
+    callback: callback,
+    pipe: pipe,
+    timer: debounceTime(wait)
+  });
+  return {
+    next: function next() {
+      return waiter.next.apply(waiter, arguments);
+    },
+    flush: function flush() {
+      return waiter.flush();
+    },
+    abort: function abort() {
+      return waiter.abort();
+    }
+  };
+};
+
+export { debounce };

package/dist/utils/effect.d.ts

@@ -0,0 +1,7 @@
+import type { EffectCallback } from "react";
+import type { ThenableEffectCallback } from "../types";
+/**
+ * @description
+ * call thenable effect
+ */
+export declare const effect: (callable: ThenableEffectCallback) => ReturnType<EffectCallback>;

package/dist/utils/effect.js

@@ -0,0 +1,16 @@
+import { isThenable } from '../is/is-thenable.js';
+
+/**
+ * @description
+ * call thenable effect
+ */
+var effect = function effect(callable) {
+  var called = callable();
+  // if result is void
+  if (!called) return void 0;
+  // if result is promise like, return void
+  if (isThenable(called)) return void 0;
+  return called;
+};
+
+export { effect };

package/dist/utils/exclude.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @description
+ * exclude any value from array
+ *
+ * for performance, avoid using `Array.includes`, replace with `Set`
+ *
+ * @example
+ * exclude([1, 2, 3, 4, 5], [2, 4]) // [1, 3, 5]
+ */
+export declare const exclude: <T, E = unknown>(value: Array<T>, _excludeBy: Array<E>) => Array<Exclude<T, E>>;

package/dist/utils/exclude.js

@@ -0,0 +1,18 @@
+/**
+ * @description
+ * exclude any value from array
+ *
+ * for performance, avoid using `Array.includes`, replace with `Set`
+ *
+ * @example
+ * exclude([1, 2, 3, 4, 5], [2, 4]) // [1, 3, 5]
+ */
+var exclude = function exclude(value, _excludeBy) {
+  var excludeBy = new Set(_excludeBy);
+  // @ts-ignore
+  return value.filter(function (item) {
+    return !excludeBy.has(item);
+  });
+};
+
+export { exclude };

package/dist/utils/range.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns an array of numbers, starting at `from` and ending at `to`.
+ * @param from number
+ * @param to number
+ * @returns number[]
+ */
+export declare const range: (from: number, to: number) => number[];

package/dist/utils/range.js

@@ -0,0 +1,16 @@
+/**
+ * Returns an array of numbers, starting at `from` and ending at `to`.
+ * @param from number
+ * @param to number
+ * @returns number[]
+ */
+var range = function range(from, to) {
+  var length = Math.max(to - from + 1, 0);
+  return Array.from({
+    length: length
+  }, function (_, index) {
+    return index + from;
+  });
+};
+
+export { range };

package/dist/utils/set-style.d.ts

@@ -0,0 +1,6 @@
+import type { Voidable } from "../types";
+/**
+ * @description
+ * set inline style util
+ */
+export declare const setStyle: (target: HTMLElement, styles: Voidable<Partial<CSSStyleDeclaration>>) => Partial<CSSStyleDeclaration>;

package/dist/utils/set-style.js

@@ -0,0 +1,21 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+
+/**
+ * @description
+ * set inline style util
+ */
+var setStyle = function setStyle(target, styles) {
+  if (!styles) return {};
+  return Object.entries(styles).reduce(function (prev, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    // @ts-ignore
+    prev[key] = target.style[key];
+    // @ts-ignore
+    target.style[key] = value;
+    return prev;
+  }, {});
+};
+
+export { setStyle };

package/dist/utils/throttle.d.ts

@@ -0,0 +1,5 @@
+import type { Debounced, Debouncer } from "./debounce";
+import { type Callable } from "../hooks/use-event";
+export type Throttled<T extends Callable> = Debounced<T>;
+export type Throttler<T extends Callable, R extends Array<unknown> = Parameters<T>> = Debouncer<T, R>;
+export declare const throttle: <T extends Callable, R extends Array<unknown> = Parameters<T>>(throttler: Throttler<T, R> | T, wait: number) => Throttled<T>;

package/dist/utils/throttle.js

@@ -0,0 +1,32 @@
+import { Waitable } from './waitable.js';
+import { isFunction } from '../is/is-function.js';
+import { throttleTime } from 'rxjs';
+
+var throttle = function throttle(throttler, wait) {
+  var isCallable = isFunction(throttler);
+  var callback = isCallable ? throttler : throttler.callback;
+  var pipe = isCallable ? function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return args;
+  } : throttler.pipe;
+  var waiter = new Waitable({
+    callback: callback,
+    pipe: pipe,
+    timer: throttleTime(wait)
+  });
+  return {
+    next: function next() {
+      return waiter.next.apply(waiter, arguments);
+    },
+    flush: function flush() {
+      return waiter.flush();
+    },
+    abort: function abort() {
+      return waiter.abort();
+    }
+  };
+};
+
+export { throttle };

package/dist/utils/to-array.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @description
+ * options
+ */
+type Options = {
+    /**
+     * @description
+     * separator
+     * only effect in `value is string`, value would be split by separator
+     */
+    separator?: string;
+};
+/**
+ * @description
+ * convert any type data to a array
+ */
+export declare const toArray: <T extends unknown = unknown>(value: T | Array<T>, { separator }?: Options) => Array<T>;
+export {};

package/dist/utils/to-array.js

@@ -0,0 +1,25 @@
+import { typeof as _typeof } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { isVoid } from '../is/is-void.js';
+
+/**
+ * @description
+ * convert any type data to a array
+ */
+var toArray = function toArray(value) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    separator = _ref.separator;
+  if (Array.isArray(value)) {
+    return value;
+  }
+  switch (_typeof(value)) {
+    case "string":
+      if (isVoid(separator)) {
+        return [value];
+      }
+      return value.split(separator);
+    default:
+      return [value];
+  }
+};
+
+export { toArray };

package/dist/utils/to-form-data.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * convert to formData
+ */
+export declare const toFormData: (data: unknown) => FormData;

package/dist/utils/to-form-data.js

@@ -0,0 +1,27 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { isArray } from '../is/is-array.js';
+
+/**
+ * @description
+ * convert to formData
+ */
+var toFormData = function toFormData(data) {
+  return Object.entries(data !== null && data !== void 0 ? data : {}).reduce(function (prev, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    // support key-value array data
+    // if value is { list: [ 11, 22 ] }
+    // like prev.append('list[]', 11);
+    if (isArray(value)) {
+      value.forEach(function (item) {
+        prev.append("".concat(key, "[]"), item);
+      });
+      return prev;
+    }
+    prev.append(key, value);
+    return prev;
+  }, new FormData());
+};
+
+export { toFormData };

package/dist/utils/to-function.d.ts

@@ -0,0 +1 @@
+export declare const toFunction: <T extends Function>(value: unknown) => T;

package/dist/utils/to-function.js

@@ -0,0 +1,13 @@
+import { isFunction } from '../is/is-function.js';
+
+var toFunction = function toFunction(value) {
+  var _isFunction = isFunction(value);
+  if (_isFunction) {
+    return value;
+  }
+  return function () {
+    return value;
+  };
+};
+
+export { toFunction };

package/dist/utils/toggle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * toggle api
+ * @description
+ * when list has current key, remove it, otherwise add it
+ *
+ * return  a copy of list
+ */
+export declare const toggle: <R, T extends Iterable<R>>(value: T, key: R) => T;

package/dist/utils/toggle.js

@@ -0,0 +1,30 @@
+import { isSet } from '../is/is-set.js';
+
+/**
+ * toggle api
+ * @description
+ * when list has current key, remove it, otherwise add it
+ *
+ * return  a copy of list
+ */
+var toggle = function toggle(value, key) {
+  if (isSet(value)) {
+    var _copied = new Set(value);
+    if (_copied.has(key)) {
+      _copied["delete"](key);
+    } else {
+      _copied.add(key);
+    }
+    return _copied;
+  }
+  var copied = Array.from(value);
+  var index = copied.indexOf(key);
+  if (index === -1) {
+    copied.push(key);
+  } else {
+    copied.splice(index, 1);
+  }
+  return copied;
+};
+
+export { toggle };

package/dist/utils/unique.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @description
+ * unique
+ */
+export declare const unique: <T = unknown>(value: Iterable<T>) => T[];
+/**
+ * @description
+ * unique by
+ */
+export declare const uniqueBy: <T, P>(value: Iterable<T>, callback: (item: T) => P) => P[];