@unicom-cloud/utils 0.1.24 → 0.1.26

package/tree/index.js

@@ -1,24 +1,25 @@
-/* 2025-10-28 09:57:10 */
+/* 2025-11-04 10:32:44 */
 import a from "lodash/castArray";
-import c from "lodash/isArray";
-import d from "lodash/isUndefined";
-import { default as A } from "./search/index.js";
-function g(t, n, r, l = "children") {
+import c from "lodash/isArray.js";
+import g from "lodash/isObject.js";
+import d from "lodash/isUndefined.js";
+import { default as j } from "./search/index.js";
+function p(t, n, l, r = "children") {
   if (c(t) && (t = {
-    [l]: t
-  }), !(t && typeof t == "object")) return null;
-  if (n in t && t[n] === r)
+    [r]: t
+  }), !(t && g(t))) return null;
+  if (n in t && t[n] === l)
     return t;
-  const f = t[l] ?? t.items ?? t.list;
+  const f = t[r] ?? t.items ?? t.list;
   if (c(f))
     for (let i of f) {
-      const e = g(i, n, r, l);
+      const e = p(i, n, l, r);
       if (e)
         return e;
     }
   return null;
 }
-function h(t, n, r, l = "children", f = !0) {
+function h(t, n, l, r = "children", f = !0) {
   if (!t) return;
   let i = [...a(t)];
   e: for (; i.length; ) {
@@ -26,9 +27,9 @@ function h(t, n, r, l = "children", f = !0) {
     if (!e) continue e;
     const u = e[n];
     if (!c(e)) {
-      if (f ? u === r : u == r)
+      if (f ? u === l : u == l)
         return e;
-      let s = e[l] ?? e.items ?? e.list;
+      let s = e[r] ?? e.items ?? e.list;
       if (d(s))
         continue e;
       e = s;
@@ -36,16 +37,16 @@ function h(t, n, r, l = "children", f = !0) {
     i = i.concat(e);
   }
 }
-function o(t, n, r, l = "children") {
+function b(t, n, l, r = "children") {
   if (!t) return;
   const f = [...a(t)];
   e: for (; f.length; ) {
     let i = f.pop();
     if (!i) continue e;
     if (!c(i)) {
-      if (i[n] === r)
+      if (i[n] === l)
         return i;
-      let e = i[l] ?? i.items ?? i.list;
+      let e = i[r] ?? i.items ?? i.list;
       if (d(e))
         continue e;
       i = e;
@@ -55,22 +56,22 @@ function o(t, n, r, l = "children") {
         f.push(i[u - 1 - e]);
   }
 }
-function I(t, n) {
+function x(t, n) {
   return h(t, "id", n);
 }
-function b(t, n, r = !0) {
-  let l = h(t, "value", n)?.label;
-  return !l && r && (l = n), l;
+function N(t, n, l = !0) {
+  let r = h(t, "value", n)?.label;
+  return !r && l && (r = n), r;
 }
-function x(t, n, r, l = "children") {
+function w(t, n, l, r = "children") {
   if (!t) return;
   let f = null;
   function i(e) {
     if (!e) return;
-    let u = c(e) ? e : e[l] ?? e.items ?? e.list ?? [];
+    let u = c(e) ? e : e[r] ?? e.items ?? e.list ?? [];
     for (let s = 0; s < u.length; s++) {
       const m = u[s];
-      if (m?.[n] === r) {
+      if (m?.[n] === l) {
         f = { item: m, parent: e, index: s };
         return;
       }
@@ -81,12 +82,12 @@ function x(t, n, r, l = "children") {
 }
 export {
   h as default,
-  g as findNodeBy,
-  x as getChildWithParentBy,
+  p as findNodeBy,
+  w as getChildWithParentBy,
   h as getItemBy,
-  o as getItemBy2,
-  g as getItemBy3,
-  I as getItemByID,
-  b as getLabelFromDictionaryByValue,
-  A as searchTree
+  b as getItemBy2,
+  p as getItemBy3,
+  x as getItemByID,
+  N as getLabelFromDictionaryByValue,
+  j as searchTree
 };

package/tree/search/index.js

@@ -1,4 +1,4 @@
-/* 2025-10-28 09:57:10 */
+/* 2025-11-04 10:32:44 */
 import E from "lodash/isArray";
 import B from "lodash/isFunction";
 import C from "lodash/isNil";

package/tree.js

@@ -1,17 +1,18 @@
-/* 2025-10-28 09:57:10 */
+/* 2025-11-04 10:32:44 */
 import "lodash/castArray";
-import "lodash/isArray";
-import "lodash/isUndefined";
-import { default as a } from "./tree/search/index.js";
-import { getItemBy as i, findNodeBy as B, getChildWithParentBy as d, getItemBy as g, getItemBy2 as f, findNodeBy as I, getItemByID as l, getLabelFromDictionaryByValue as p } from "./tree/index.js";
+import "lodash/isArray.js";
+import "lodash/isObject.js";
+import "lodash/isUndefined.js";
+import { default as i } from "./tree/search/index.js";
+import { getItemBy as B, findNodeBy as d, getChildWithParentBy as g, getItemBy as f, getItemBy2 as p, findNodeBy as I, getItemByID as l, getLabelFromDictionaryByValue as n } from "./tree/index.js";
 export {
-  i as default,
-  B as findNodeBy,
-  d as getChildWithParentBy,
-  g as getItemBy,
-  f as getItemBy2,
+  B as default,
+  d as findNodeBy,
+  g as getChildWithParentBy,
+  f as getItemBy,
+  p as getItemBy2,
   I as getItemBy3,
   l as getItemByID,
-  p as getLabelFromDictionaryByValue,
-  a as searchTree
+  n as getLabelFromDictionaryByValue,
+  i as searchTree
 };

package/tween/index.js

@@ -0,0 +1,8 @@
+/* 2025-11-04 10:32:44 */
+import * as e from "./src/easing.js";
+import { default as r, default as t } from "./src/tween.js";
+export {
+  r as Tween,
+  t as default,
+  e as easing
+};

package/tween/src/easing.js

@@ -0,0 +1,62 @@
+/* 2025-11-04 10:32:44 */
+function u(n) {
+  return function(t) {
+    return Math.pow(t, n);
+  };
+}
+function r(n) {
+  return function(t) {
+    return 1 - Math.abs(Math.pow(t - 1, n));
+  };
+}
+function c(n) {
+  return function(t) {
+    return t < 0.5 ? u(n)(t * 2) / 2 : r(n)(t * 2 - 1) / 2 + 0.5;
+  };
+}
+function s(n) {
+  return n;
+}
+const a = u(2), I = r(2), f = c(2), O = u(3), h = r(3), M = c(3), p = u(4), q = r(4), b = c(4), P = u(5), d = r(5), l = c(5);
+function y(n) {
+  return 1 + Math.sin(Math.PI / 2 * n - Math.PI / 2);
+}
+function B(n) {
+  return Math.sin(Math.PI / 2 * n);
+}
+function w(n) {
+  return (1 + Math.sin(Math.PI * n - Math.PI / 2)) / 2;
+}
+function e(n) {
+  return n < 1 / 2.75 ? 7.5625 * n * n : n < 2 / 2.75 ? (n -= 1.5 / 2.75, 7.5625 * n * n + 0.75) : n < 2.5 / 2.75 ? (n -= 2.25 / 2.75, 7.5625 * n * n + 0.9375) : (n -= 2.625 / 2.75, 7.5625 * n * n + 0.984375);
+}
+function o(n) {
+  return 1 - e(1 - n);
+}
+function x(n) {
+  return n < 0.5 ? o(n * 2) * 0.5 : e(n * 2 - 1) * 0.5 + 0.5;
+}
+export {
+  o as bounceIn,
+  x as bounceInOut,
+  e as bounceOut,
+  O as cubicIn,
+  M as cubicInOut,
+  h as cubicOut,
+  u as easeInBy,
+  c as easeInOutBy,
+  r as easeOutBy,
+  s as linear,
+  a as quadIn,
+  f as quadInOut,
+  I as quadOut,
+  p as quartIn,
+  b as quartInOut,
+  q as quartOut,
+  P as quintIn,
+  l as quintInOut,
+  d as quintOut,
+  y as sineIn,
+  w as sineInOut,
+  B as sineOut
+};

package/tween/src/tween.js

@@ -0,0 +1,46 @@
+/* 2025-11-04 10:32:44 */
+import n from "lodash/isFunction.js";
+import d from "lodash/isString.js";
+import * as l from "./easing.js";
+import { linear as u } from "./easing.js";
+class F {
+  constructor(i) {
+    const {
+      from: s,
+      to: e,
+      duration: a = 500,
+      delay: r = 0,
+      easing: h,
+      onStart: o,
+      onUpdate: f = function() {
+      },
+      onFinish: m
+    } = i;
+    for (const t in s)
+      e[t] === void 0 && (e[t] = s[t]);
+    for (const t in e)
+      s[t] === void 0 && (s[t] = e[t]);
+    this.from = s, this.to = e, this.duration = a, this.delay = r, n(h) ? this.easing = h : d(h) && (this.easing = l[h]), this.easing ||= u, this.onStart = o, this.onUpdate = f, this.onFinish = m, this.startTime = Date.now() + this.delay, this.started = !1, this.finished = !1, this.timer = null, this.keys = {};
+  }
+  update() {
+    if (this.time = Date.now(), !(this.time < this.startTime) && !this.finished) {
+      this.elapsed = this.time - this.startTime, this.elapsed = Math.min(this.elapsed, this.duration);
+      for (const i in this.to)
+        this.keys[i] = this.from[i] + (this.to[i] - this.from[i]) * this.easing(this.elapsed / this.duration);
+      this.started || (n(this.onStart) && this.onStart(this.keys), this.started = !0), n(this.onUpdate) && this.onUpdate(this.keys), this.elapsed === this.duration && !this.finished && (this.finished = !0, n(this.onFinish) && this.onFinish(this.keys));
+    }
+  }
+  start() {
+    this.startTime = Date.now() + this.delay, this.started = !1, this.finished = !1;
+    const i = () => {
+      this.update(), this.finished ? this.timer && (cancelAnimationFrame(this.timer), this.timer = null) : this.timer = requestAnimationFrame(i);
+    };
+    this.timer = requestAnimationFrame(i);
+  }
+  stop() {
+    this.timer && (cancelAnimationFrame(this.timer), this.timer = null), this.finished = !0;
+  }
+}
+export {
+  F as default
+};

package/tween.js

@@ -0,0 +1,8 @@
+/* 2025-11-04 10:32:44 */
+import * as e from "./tween/src/easing.js";
+import { default as r, default as t } from "./tween/src/tween.js";
+export {
+  r as Tween,
+  t as default,
+  e as easing
+};

package/types/axios/index.d.ts

@@ -0,0 +1,19 @@
+export const all: any;
+export const Axios: any;
+export const AxiosError: any;
+export const AxiosHeaders: any;
+import utils from './lib/utils.js';
+export const Cancel: any;
+export const CanceledError: any;
+export const CancelToken: any;
+import axios from './lib/axios.js';
+export const formToJSON: any;
+export const getAdapter: any;
+export const HttpStatusCode: any;
+export const isAxiosError: any;
+export const isCancel: any;
+export const mergeConfig: any;
+export const spread: any;
+export const toFormData: any;
+export const VERSION: any;
+export { utils as AxiosUtils, axios as default };

package/types/axios/lib/adapters/adapters.d.ts

@@ -0,0 +1,28 @@
+declare namespace _default {
+    export { getAdapter };
+    export { knownAdapters as adapters };
+}
+export default _default;
+/**
+ * Get the first suitable adapter from the provided list.
+ * Tries each adapter in order until a supported one is found.
+ * Throws an AxiosError if no adapter is suitable.
+ *
+ * @param {Array<string|Function>|string|Function} adapters - Adapter(s) by name or function.
+ * @param {Object} config - Axios request configuration
+ * @throws {AxiosError} If no suitable adapter is available
+ * @returns {Function} The resolved adapter function
+ */
+declare function getAdapter(adapters: Array<string | Function> | string | Function, config: Object): Function;
+/**
+ * Known adapters mapping.
+ * Provides environment-specific adapters for Axios:
+ * - `http` for Node.js
+ * - `xhr` for browsers
+ * - `fetch` for fetch API-based requests
+ *
+ * @type {Object<string, Function|Object>}
+ */
+declare const knownAdapters: {
+    [x: string]: Object | Function;
+};

package/types/axios/lib/adapters/fetch.d.ts

@@ -0,0 +1,3 @@
+export function getFetch(config: any): any;
+export default adapter;
+declare const adapter: any;

package/types/axios/lib/adapters/http.d.ts

@@ -0,0 +1,12 @@
+declare const _default: false | ((config: any) => Promise<any>);
+export default _default;
+/**
+ * If the proxy or config afterRedirects functions are defined, call them with the options
+ *
+ * @param {http.ClientRequestArgs} options
+ * @param {AxiosProxyConfig} configProxy configuration from Axios options object
+ * @param {string} location
+ *
+ * @returns {http.ClientRequestArgs}
+ */
+export function __setProxy(options: http.ClientRequestArgs, configProxy: AxiosProxyConfig, location: string): http.ClientRequestArgs;

package/types/axios/lib/adapters/xhr.d.ts

@@ -0,0 +1,2 @@
+declare const _default: false | ((config: any) => Promise<any>);
+export default _default;

package/types/axios/lib/axios.d.ts

@@ -0,0 +1,3 @@
+export default axios;
+declare const axios: Axios;
+import Axios from './core/Axios.js';

package/types/axios/lib/cancel/CancelToken.d.ts

@@ -0,0 +1,34 @@
+export default CancelToken;
+/**
+ * A `CancelToken` is an object that can be used to request cancellation of an operation.
+ *
+ * @param {Function} executor The executor function.
+ *
+ * @returns {CancelToken}
+ */
+declare class CancelToken {
+    /**
+     * Returns an object that contains a new `CancelToken` and a function that, when called,
+     * cancels the `CancelToken`.
+     */
+    static source(): {
+        token: CancelToken;
+        cancel: undefined;
+    };
+    constructor(executor: any);
+    promise: Promise<any>;
+    /**
+     * Throws a `CanceledError` if cancellation has been requested.
+     */
+    throwIfRequested(): void;
+    /**
+     * Subscribe to the cancel signal
+     */
+    subscribe(listener: any): void;
+    _listeners: any[] | undefined;
+    /**
+     * Unsubscribe from the cancel signal
+     */
+    unsubscribe(listener: any): void;
+    toAbortSignal(): AbortSignal;
+}

package/types/axios/lib/cancel/CanceledError.d.ts

@@ -0,0 +1,24 @@
+export default CanceledError;
+/**
+ * A `CanceledError` is an object that is thrown when an operation is canceled.
+ *
+ * @param {string=} message The message.
+ * @param {Object=} config The config.
+ * @param {Object=} request The request.
+ *
+ * @returns {CanceledError} The created error.
+ */
+declare function CanceledError(message?: string | undefined, config?: Object | undefined, request?: Object | undefined): CanceledError;
+declare class CanceledError {
+    /**
+     * A `CanceledError` is an object that is thrown when an operation is canceled.
+     *
+     * @param {string=} message The message.
+     * @param {Object=} config The config.
+     * @param {Object=} request The request.
+     *
+     * @returns {CanceledError} The created error.
+     */
+    constructor(message?: string | undefined, config?: Object | undefined, request?: Object | undefined);
+    name: string;
+}

package/types/axios/lib/cancel/isCancel.d.ts

@@ -0,0 +1 @@
+export default function isCancel(value: any): boolean;

package/types/axios/lib/core/Axios.d.ts

@@ -0,0 +1,28 @@
+export default Axios;
+/**
+ * Create a new instance of Axios
+ *
+ * @param {Object} instanceConfig The default config for the instance
+ *
+ * @return {Axios} A new instance of Axios
+ */
+declare class Axios {
+    constructor(instanceConfig: any);
+    defaults: any;
+    interceptors: {
+        request: InterceptorManager;
+        response: InterceptorManager;
+    };
+    /**
+     * Dispatch a request
+     *
+     * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
+     * @param {?Object} config
+     *
+     * @returns {Promise} The Promise to be fulfilled
+     */
+    request(configOrUrl: string | Object, config: Object | null): Promise<any>;
+    _request(configOrUrl: any, config: any): Promise<any>;
+    getUri(config: any): string;
+}
+import InterceptorManager from './InterceptorManager.js';

package/types/axios/lib/core/AxiosError.d.ts

@@ -0,0 +1,38 @@
+export default AxiosError;
+/**
+ * Create an Error with the specified message, config, error code, request and response.
+ *
+ * @param {string} message The error message.
+ * @param {string} [code] The error code (for example, 'ECONNABORTED').
+ * @param {Object} [config] The config.
+ * @param {Object} [request] The request.
+ * @param {Object} [response] The response.
+ *
+ * @returns {Error} The created error.
+ */
+declare function AxiosError(message: string, code?: string, config?: Object, request?: Object, response?: Object): Error;
+declare class AxiosError {
+    /**
+     * Create an Error with the specified message, config, error code, request and response.
+     *
+     * @param {string} message The error message.
+     * @param {string} [code] The error code (for example, 'ECONNABORTED').
+     * @param {Object} [config] The config.
+     * @param {Object} [request] The request.
+     * @param {Object} [response] The response.
+     *
+     * @returns {Error} The created error.
+     */
+    constructor(message: string, code?: string, config?: Object, request?: Object, response?: Object);
+    stack: string | undefined;
+    message: string;
+    name: string;
+    code: string | undefined;
+    config: Object | undefined;
+    request: Object | undefined;
+    response: Object | undefined;
+    status: any;
+}
+declare namespace AxiosError {
+    function from(error: any, code: any, config: any, request: any, response: any, customProps: any): any;
+}

package/types/axios/lib/core/AxiosHeaders.d.ts

@@ -0,0 +1,23 @@
+export default AxiosHeaders;
+declare class AxiosHeaders {
+    static from(thing: any): AxiosHeaders;
+    static concat(first: any, ...targets: any[]): AxiosHeaders;
+    static accessor(header: any): typeof AxiosHeaders;
+    constructor(headers: any);
+    set(header: any, valueOrRewrite: any, rewrite: any): this;
+    get(header: any, parser: any): any;
+    has(header: any, matcher: any): boolean;
+    delete(header: any, matcher: any): boolean;
+    clear(matcher: any): boolean;
+    normalize(format: any): this;
+    concat(...targets: any[]): any;
+    toJSON(asStrings: any): any;
+    toString(): string;
+    getSetCookie(): any;
+    [Symbol.iterator](): ArrayIterator<[string, any]>;
+    get [Symbol.toStringTag](): string;
+    [$internals]: {
+        accessors: {};
+    } | undefined;
+}
+declare const $internals: unique symbol;

package/types/axios/lib/core/InterceptorManager.d.ts

@@ -0,0 +1,38 @@
+export default InterceptorManager;
+declare class InterceptorManager {
+    handlers: any[];
+    /**
+     * Add a new interceptor to the stack
+     *
+     * @param {Function} fulfilled The function to handle `then` for a `Promise`
+     * @param {Function} rejected The function to handle `reject` for a `Promise`
+     *
+     * @return {Number} An ID used to remove interceptor later
+     */
+    use(fulfilled: Function, rejected: Function, options: any): number;
+    /**
+     * Remove an interceptor from the stack
+     *
+     * @param {Number} id The ID that was returned by `use`
+     *
+     * @returns {void}
+     */
+    eject(id: number): void;
+    /**
+     * Clear all interceptors from the stack
+     *
+     * @returns {void}
+     */
+    clear(): void;
+    /**
+     * Iterate over all the registered interceptors
+     *
+     * This method is particularly useful for skipping over any
+     * interceptors that may have become `null` calling `eject`.
+     *
+     * @param {Function} fn The function to call for each interceptor
+     *
+     * @returns {void}
+     */
+    forEach(fn: Function): void;
+}

package/types/axios/lib/core/buildFullPath.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates a new URL by combining the baseURL with the requestedURL,
+ * only when the requestedURL is not already an absolute URL.
+ * If the requestURL is absolute, this function returns the requestedURL untouched.
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} requestedURL Absolute or relative URL to combine
+ *
+ * @returns {string} The combined full path
+ */
+export default function buildFullPath(baseURL: string, requestedURL: string, allowAbsoluteUrls: any): string;

package/types/axios/lib/core/dispatchRequest.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dispatch a request to the server using the configured adapter.
+ *
+ * @param {object} config The config that is to be used for the request
+ *
+ * @returns {Promise} The Promise to be fulfilled
+ */
+export default function dispatchRequest(config: object): Promise<any>;

package/types/axios/lib/core/mergeConfig.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Config-specific merge-function which creates a new config-object
+ * by merging two configuration objects together.
+ *
+ * @param {Object} config1
+ * @param {Object} config2
+ *
+ * @returns {Object} New object resulting from merging config2 to config1
+ */
+export default function mergeConfig(config1: Object, config2: Object): Object;

package/types/axios/lib/core/settle.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Resolve or reject a Promise based on response status.
+ *
+ * @param {Function} resolve A function that resolves the promise.
+ * @param {Function} reject A function that rejects the promise.
+ * @param {object} response The response.
+ *
+ * @returns {object} The response.
+ */
+export default function settle(resolve: Function, reject: Function, response: object): object;

package/types/axios/lib/core/transformData.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Transform the data for a request or a response
+ *
+ * @param {Array|Function} fns A single function or Array of functions
+ * @param {?Object} response The response object
+ *
+ * @returns {*} The resulting transformed data
+ */
+export default function transformData(fns: any[] | Function, response: Object | null): any;

package/types/axios/lib/defaults/index.d.ts

@@ -0,0 +1,30 @@
+export default defaults;
+declare namespace defaults {
+    export { transitionalDefaults as transitional };
+    export let adapter: string[];
+    export let transformRequest: ((data: any, headers: any) => any)[];
+    export let transformResponse: ((data: any) => any)[];
+    export let timeout: number;
+    export let xsrfCookieName: string;
+    export let xsrfHeaderName: string;
+    export let maxContentLength: number;
+    export let maxBodyLength: number;
+    export namespace env {
+        let FormData: {
+            new (form?: HTMLFormElement, submitter?: HTMLElement | null): FormData;
+            prototype: FormData;
+        } | null;
+        let Blob: {
+            new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+            prototype: Blob;
+        } | null;
+    }
+    export function validateStatus(status: any): boolean;
+    export namespace headers {
+        let common: {
+            Accept: string;
+            'Content-Type': undefined;
+        };
+    }
+}
+import transitionalDefaults from './transitional.js';

package/types/axios/lib/defaults/transitional.d.ts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let silentJSONParsing: boolean;
+    let forcedJSONParsing: boolean;
+    let clarifyTimeoutError: boolean;
+}
+export default _default;

package/types/axios/lib/env/classes/FormData.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/types/axios/lib/env/data.d.ts

@@ -0,0 +1 @@
+export const VERSION: "1.13.1";