@unicom-cloud/utils 0.1.10 → 0.1.12

package/types/tinycolor/src/interfaces.d.ts

@@ -0,0 +1,57 @@
+/**
+ * convert all properties in an interface to a number
+ */
+export type Numberify<T> = {
+    [P in keyof T]: number;
+};
+/**
+ * A representation of additive color mixing.
+ * Projection of primary color lights on a white screen shows secondary
+ * colors where two overlap; the combination of all three of red, green,
+ * and blue in equal intensities makes white.
+ */
+export interface RGB {
+    r: number | string;
+    g: number | string;
+    b: number | string;
+}
+export interface RGBA extends RGB {
+    a: number;
+}
+/**
+ * The HSL model describes colors in terms of hue, saturation,
+ * and lightness (also called luminance).
+ * @link https://en.wikibooks.org/wiki/Color_Models:_RGB,_HSV,_HSL#HSL
+ */
+export interface HSL {
+    h: number | string;
+    s: number | string;
+    l: number | string;
+}
+export interface HSLA extends HSL {
+    a: number;
+}
+/**
+ * The HSV, or HSB, model describes colors in terms of
+ * hue, saturation, and value (brightness).
+ * @link https://en.wikibooks.org/wiki/Color_Models:_RGB,_HSV,_HSL#HSV
+ */
+export interface HSV {
+    h: number | string;
+    s: number | string;
+    v: number | string;
+}
+export interface HSVA extends HSV {
+    a: number;
+}
+/**
+ * The CMYK color model is a subtractive color model used in the printing process.
+ * It described four ink palettes: Cyan, Magenta, Yellow, and Black.
+ * @link https://en.wikipedia.org/wiki/CMYK_color_model
+ */
+export interface CMYK {
+    c: number | string;
+    m: number | string;
+    y: number | string;
+    k: number | string;
+}

package/types/tinycolor/src/public_api.d.ts

@@ -0,0 +1,10 @@
+export * from './conversion.js';
+export * from './css-color-names.js';
+export * from './format-input.js';
+export * from './from-ratio.js';
+export * from './index.js';
+export * from './interfaces.js';
+export * from './random.js';
+export * from './readability.js';
+export * from './to-ms-filter.js';
+export * from './util.js';

package/types/tinycolor/src/random.d.ts

@@ -0,0 +1,24 @@
+import { TinyColor } from './index.js';
+export interface RandomOptions {
+    seed?: number;
+    hue?: number | string | 'red' | 'orange' | 'yellow' | 'green' | 'blue' | 'purple' | 'pink' | 'monochrome';
+    luminosity?: 'random' | 'bright' | 'dark' | 'light';
+    alpha?: number;
+}
+export interface RandomCountOptions extends RandomOptions {
+    count?: number | null;
+}
+export declare function random(options?: RandomOptions): TinyColor;
+export declare function random(options?: RandomCountOptions): TinyColor[];
+/**
+ * @hidden
+ */
+export interface ColorBound {
+    name: string;
+    hueRange: [number, number] | null;
+    lowerBounds: Array<[number, number]>;
+}
+/**
+ * @hidden
+ */
+export declare const bounds: ColorBound[];

package/types/tinycolor/src/readability.d.ts

@@ -0,0 +1,46 @@
+import { ColorInput, TinyColor } from './index.js';
+/**
+ * AKA `contrast`
+ *
+ * Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
+ */
+export declare function readability(color1: ColorInput, color2: ColorInput): number;
+export interface WCAG2Parms {
+    level?: 'AA' | 'AAA';
+    size?: 'large' | 'small';
+}
+/**
+ * Ensure that foreground and background color combinations meet WCAG2 guidelines.
+ * The third argument is an object.
+ *      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
+ *      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
+ * If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.
+ *
+ * Example
+ * ```ts
+ * new TinyColor().isReadable('#000', '#111') => false
+ * new TinyColor().isReadable('#000', '#111', { level: 'AA', size: 'large' }) => false
+ * ```
+ */
+export declare function isReadable(color1: ColorInput, color2: ColorInput, wcag2?: WCAG2Parms): boolean;
+export interface WCAG2FallbackParms extends WCAG2Parms {
+    includeFallbackColors?: boolean;
+}
+/**
+ * Given a base color and a list of possible foreground or background
+ * colors for that base, returns the most readable color.
+ * Optionally returns Black or White if the most readable color is unreadable.
+ *
+ * @param baseColor - the base color.
+ * @param colorList - array of colors to pick the most readable one from.
+ * @param args - and object with extra arguments
+ *
+ * Example
+ * ```ts
+ * new TinyColor().mostReadable('#123', ['#124", "#125'], { includeFallbackColors: false }).toHexString(); // "#112255"
+ * new TinyColor().mostReadable('#123', ['#124", "#125'],{ includeFallbackColors: true }).toHexString();  // "#ffffff"
+ * new TinyColor().mostReadable('#a8015a', ["#faf3f3"], { includeFallbackColors:true, level: 'AAA', size: 'large' }).toHexString(); // "#faf3f3"
+ * new TinyColor().mostReadable('#a8015a', ["#faf3f3"], { includeFallbackColors:true, level: 'AAA', size: 'small' }).toHexString(); // "#ffffff"
+ * ```
+ */
+export declare function mostReadable(baseColor: ColorInput, colorList: ColorInput[], args?: WCAG2FallbackParms): TinyColor | null;

package/types/tinycolor/src/to-ms-filter.d.ts

@@ -0,0 +1,5 @@
+import { ColorInput } from './index.js';
+/**
+ * Returns the color represented as a Microsoft filter for use in old versions of IE.
+ */
+export declare function toMsFilter(firstColor: ColorInput, secondColor?: ColorInput): string;

package/types/tinycolor/src/umd_api.d.ts

@@ -0,0 +1,22 @@
+import { names } from './css-color-names.js';
+import { inputToRGB, isValidCSSUnit, stringInputToObject } from './format-input.js';
+import { fromRatio, legacyRandom } from './from-ratio.js';
+import { TinyColor } from './index.js';
+import { random } from './random.js';
+import { mostReadable, readability } from './readability.js';
+import { toMsFilter } from './to-ms-filter.js';
+export interface TinyColorUMD {
+    TinyColor: typeof TinyColor;
+    readability: typeof readability;
+    random: typeof random;
+    names: typeof names;
+    fromRatio: typeof fromRatio;
+    legacyRandom: typeof legacyRandom;
+    toMsFilter: typeof toMsFilter;
+    inputToRGB: typeof inputToRGB;
+    stringInputToObject: typeof stringInputToObject;
+    isValidCSSUnit: typeof isValidCSSUnit;
+    mostReadable: typeof mostReadable;
+}
+declare const tinycolorumd: TinyColorUMD;
+export default tinycolorumd;

package/types/tinycolor/src/util.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Take input from [0, n] and return it as [0, 1]
+ * @hidden
+ */
+export declare function bound01(n: any, max: number): number;
+/**
+ * Force a number between 0 and 1
+ * @hidden
+ */
+export declare function clamp01(val: number): number;
+/**
+ * Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
+ * <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
+ * @hidden
+ */
+export declare function isOnePointZero(n: string | number): boolean;
+/**
+ * Check to see if string passed in is a percentage
+ * @hidden
+ */
+export declare function isPercentage(n: string | number): boolean;
+/**
+ * Return a valid alpha value [0,1] with all invalid values being set to 1
+ * @hidden
+ */
+export declare function boundAlpha(a?: number | string): number;
+/**
+ * Replace a decimal with it's percentage value
+ * @hidden
+ */
+export declare function convertToPercentage(n: number | string): number | string;
+/**
+ * Force a hex value to have 2 characters
+ * @hidden
+ */
+export declare function pad2(c: string): string;

package/types/tree/index.d.ts

@@ -0,0 +1,9 @@
+export function findNodeBy(root: any, key: any, value: any, childrenKey?: string): any;
+export function getItemBy(root: any, key: any, value: any, childrenKey?: string): any;
+export function getItemBy3(root: any, key: any, value: any, childrenKey?: string): any;
+export function getItemByID(root: any, value: any): any;
+export function getLabelFromDictionaryByValue(a: any, value: any, 保底?: boolean): any;
+export function getChildWithParentBy(root: any, key: any, value: any, childrenKey?: string): null | undefined;
+export function getItemBy2(root: any, key: any, value: any, childrenKey?: string): any;
+export default getItemBy;
+export { default as searchTree } from "./searchTree";

package/types/tree/searchTree.d.ts

@@ -0,0 +1,20 @@
+type Primitive = string | number | boolean | symbol | null | undefined;
+type ConditionValue<T = unknown> = Primitive | ((value: T) => boolean) | RegExp;
+interface SearchOptions {
+    strategy?: 'BFS' | 'DFS';
+    childrenKey?: string;
+    strict?: boolean;
+}
+interface TreeNode {
+    [key: string]: unknown;
+    children?: TreeNode[];
+}
+/**
+ * 非递归树搜索算法
+ * @param {TreeNode[]} treeData - 树数据
+ * @param {Record<string, ConditionValue>} searchCondition - 搜索条件对象
+ * @param {SearchOptions} [options={}] - 配置选项
+ * @returns {TreeNode | null} 找到的节点或null
+ */
+declare function searchTree(treeData: TreeNode[], searchCondition: Record<string, ConditionValue>, options?: SearchOptions): TreeNode | null;
+export default searchTree;

package/types/turbo-stream/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/turbo-stream";

package/types/turbo-stream/src/decode.d.ts

@@ -0,0 +1,7 @@
+export type DecodePlugin = (type: string, ...data: unknown[]) => {
+    value: unknown;
+} | false | null | undefined;
+export type DecodeOptions = {
+    plugins?: DecodePlugin[];
+};
+export declare function decode<T>(stream: ReadableStream<string>, { plugins }?: DecodeOptions): Promise<T>;

package/types/turbo-stream/src/encode.d.ts

@@ -0,0 +1,27 @@
+declare const ASYNC_FRAME_TYPE_PROMISE = 1;
+declare const ASYNC_FRAME_TYPE_ITERABLE = 2;
+type AsyncFrame = [
+    type: typeof ASYNC_FRAME_TYPE_PROMISE,
+    id: number,
+    promise: PromiseLike<unknown>
+] | [
+    type: typeof ASYNC_FRAME_TYPE_ITERABLE,
+    id: number,
+    iterable: AsyncIterable<unknown>
+];
+export type EncodePlugin = (value: unknown) => [string, ...unknown[]] | false | null | undefined;
+export type EncodeOptions = {
+    plugins?: EncodePlugin[];
+    redactErrors?: boolean | string;
+    signal?: AbortSignal;
+};
+export declare function encode(value: unknown, { plugins, redactErrors, signal }?: EncodeOptions): ReadableStream<string>;
+export declare function encodeSync(value: unknown, chunks: {
+    push(...chunk: string[]): void;
+}, refs: WeakMap<object, number>, promises: WeakMap<object, number>, asyncFrames: {
+    push(frame: AsyncFrame): void;
+}, counters: {
+    refId: number;
+    promiseId: number;
+}, plugins: EncodePlugin[], redactErrors: boolean | string): void;
+export {};

package/types/turbo-stream/src/shared.d.ts

@@ -0,0 +1,107 @@
+export declare const STR_ARRAY_BUFFER = "A";
+export declare const STR_ASYNC_ITERABLE = "*";
+export declare const STR_BIG_INT_64_ARRAY = "J";
+export declare const STR_BIG_UINT_64_ARRAY = "j";
+export declare const STR_BIGINT = "b";
+export declare const STR_BLOB = "K";
+export declare const STR_DATA_VIEW = "V";
+export declare const STR_DATE = "D";
+export declare const STR_ERROR = "E";
+export declare const STR_FAILURE = "!";
+export declare const STR_FALSE = "false";
+export declare const STR_FILE = "k";
+export declare const STR_FLOAT_32_ARRAY = "H";
+export declare const STR_FLOAT_64_ARRAY = "h";
+export declare const STR_FORM_DATA = "F";
+export declare const STR_INFINITY = "I";
+export declare const STR_INT_16_ARRAY = "L";
+export declare const STR_INT_32_ARRAY = "G";
+export declare const STR_INT_8_ARRAY = "O";
+export declare const STR_MAP = "M";
+export declare const STR_NaN = "NaN";
+export declare const STR_NEGATIVE_INFINITY = "i";
+export declare const STR_NEGATIVE_ZERO = "z";
+export declare const STR_NULL = "null";
+export declare const STR_PLUGIN = "P";
+export declare const STR_PROMISE = "$";
+export declare const STR_READABLE_STREAM = "R";
+export declare const STR_REDACTED = "<redacted>";
+export declare const STR_REFERENCE_SYMBOL = "@";
+export declare const STR_REGEXP = "r";
+export declare const STR_SET = "S";
+export declare const STR_SUCCESS = ":";
+export declare const STR_SYMBOL = "s";
+export declare const STR_TRUE = "true";
+export declare const STR_UINT_16_ARRAY = "l";
+export declare const STR_UINT_32_ARRAY = "g";
+export declare const STR_UINT_8_ARRAY = "o";
+export declare const STR_UINT_8_ARRAY_CLAMPED = "C";
+export declare const STR_UNDEFINED = "u";
+export declare const STR_URL = "U";
+declare let SUPPORTS_FILE: boolean;
+export { SUPPORTS_FILE };
+export declare class WaitGroup {
+    #private;
+    p: number;
+    add(): void;
+    done(): void;
+    wait(): Promise<void>;
+}
+export declare class Deferred<T> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (error: unknown) => void;
+    constructor();
+}
+export declare class DeferredAsyncIterable<T> {
+    #private;
+    iterable: AsyncIterable<T>;
+    constructor();
+    resolve(): void;
+    reject(error: unknown): void;
+    yield(value: T): void;
+}
+export declare class DeferredReadableStream<T> extends DeferredAsyncIterable<T> {
+    readable: ReadableStream<T>;
+}
+export declare class TurboBlob extends Blob {
+    #private;
+    promise?: Promise<ArrayBuffer>;
+    constructor();
+    constructor(from: TurboBlob, start: number | undefined, end: number | undefined, contentType: string | undefined);
+    get size(): number;
+    set size(value: number);
+    get type(): string;
+    set type(value: string);
+    arrayBuffer(): Promise<ArrayBuffer>;
+    bytes(): Promise<Uint8Array>;
+    slice(start?: number, end?: number, contentType?: string): Blob;
+    stream(): ReadableStream<Uint8Array>;
+    text(): Promise<string>;
+}
+declare const FileBaseClass: {
+    new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+    prototype: File;
+} | {
+    new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+    prototype: Blob;
+};
+export declare class TurboFile extends FileBaseClass {
+    #private;
+    promise?: Promise<ArrayBuffer>;
+    constructor();
+    constructor(from: TurboFile, start: number | undefined, end: number | undefined, contentType: string | undefined);
+    get name(): string;
+    set name(value: string);
+    get lastModified(): number;
+    set lastModified(value: number);
+    get size(): number;
+    set size(value: number);
+    get type(): string;
+    set type(value: string);
+    arrayBuffer(): Promise<ArrayBuffer>;
+    bytes(): Promise<Uint8Array>;
+    slice(start?: number, end?: number, contentType?: string): Blob;
+    stream(): ReadableStream<Uint8Array>;
+    text(): Promise<string>;
+}

package/types/turbo-stream/src/turbo-stream.d.ts

@@ -0,0 +1,4 @@
+export { decode } from './decode.js';
+export type { DecodeOptions, DecodePlugin } from './decode.js';
+export { encode } from './encode.js';
+export type { EncodeOptions, EncodePlugin } from './encode.js';

package/types/ui-color/compareColorByRange.d.ts

@@ -0,0 +1,2 @@
+export default compareColorByRange;
+declare function compareColorByRange(range?: number[]): (percentage?: number) => string;

package/types/ui-color/index.d.ts

@@ -0,0 +1,183 @@
+export { default as compareColorByRange } from "./compareColorByRange";
+export namespace blue {
+    namespace name {
+        let zh: string;
+        let en: string;
+    }
+    let value: string;
+}
+export const colorPresets: {
+    key: string;
+    name: {
+        zh: string;
+        en: string;
+    };
+    primary: string;
+    light: TinyColor[];
+    dark: TinyColor[];
+}[];
+export const colors: {
+    name: {
+        zh: string;
+        en: string;
+    };
+    value: string;
+}[];
+export namespace cyan {
+    export namespace name_1 {
+        let zh_1: string;
+        export { zh_1 as zh };
+        let en_1: string;
+        export { en_1 as en };
+    }
+    export { name_1 as name };
+    let value_1: string;
+    export { value_1 as value };
+}
+export function generate(options?: {}): TinyColor[];
+export function generateDark(options?: {}): TinyColor[];
+export namespace gold {
+    export namespace name_2 {
+        let zh_2: string;
+        export { zh_2 as zh };
+        let en_2: string;
+        export { en_2 as en };
+    }
+    export { name_2 as name };
+    let value_2: string;
+    export { value_2 as value };
+}
+export namespace gray {
+    export namespace name_3 {
+        let zh_3: string;
+        export { zh_3 as zh };
+        let en_3: string;
+        export { en_3 as en };
+    }
+    export { name_3 as name };
+    let value_3: string;
+    export { value_3 as value };
+}
+export namespace grayPresets {
+    export let key: string;
+    import name_4 = gray.name;
+    export { name_4 as name };
+    import primary = gray.value;
+    export { primary };
+    export let light: TinyColor[];
+    export let dark: TinyColor[];
+}
+export namespace green {
+    export namespace name_5 {
+        let zh_4: string;
+        export { zh_4 as zh };
+        let en_4: string;
+        export { en_4 as en };
+    }
+    export { name_5 as name };
+    let value_4: string;
+    export { value_4 as value };
+}
+export const LENGTH: 10;
+export namespace lime {
+    export namespace name_6 {
+        let zh_5: string;
+        export { zh_5 as zh };
+        let en_5: string;
+        export { en_5 as en };
+    }
+    export { name_6 as name };
+    let value_5: string;
+    export { value_5 as value };
+}
+export namespace magenta {
+    export namespace name_7 {
+        let zh_6: string;
+        export { zh_6 as zh };
+        let en_6: string;
+        export { en_6 as en };
+    }
+    export { name_7 as name };
+    let value_6: string;
+    export { value_6 as value };
+}
+export namespace orange {
+    export namespace name_8 {
+        let zh_7: string;
+        export { zh_7 as zh };
+        let en_7: string;
+        export { en_7 as en };
+    }
+    export { name_8 as name };
+    let value_7: string;
+    export { value_7 as value };
+}
+export namespace orangered {
+    export namespace name_9 {
+        let zh_8: string;
+        export { zh_8 as zh };
+        let en_8: string;
+        export { en_8 as en };
+    }
+    export { name_9 as name };
+    let value_8: string;
+    export { value_8 as value };
+}
+export function palette(options?: {}): TinyColor;
+export function paletteDark(options?: {}): TinyColor;
+export namespace pinkpurple {
+    export namespace name_10 {
+        let zh_9: string;
+        export { zh_9 as zh };
+        let en_9: string;
+        export { en_9 as en };
+    }
+    export { name_10 as name };
+    let value_9: string;
+    export { value_9 as value };
+}
+export namespace primary {
+    export namespace name_11 {
+        let zh_10: string;
+        export { zh_10 as zh };
+        let en_10: string;
+        export { en_10 as en };
+    }
+    export { name_11 as name };
+    let value_10: string;
+    export { value_10 as value };
+}
+export namespace purple {
+    export namespace name_12 {
+        let zh_11: string;
+        export { zh_11 as zh };
+        let en_11: string;
+        export { en_11 as en };
+    }
+    export { name_12 as name };
+    let value_11: string;
+    export { value_11 as value };
+}
+export namespace red {
+    export namespace name_13 {
+        let zh_12: string;
+        export { zh_12 as zh };
+        let en_12: string;
+        export { en_12 as en };
+    }
+    export { name_13 as name };
+    let value_12: string;
+    export { value_12 as value };
+}
+export namespace yellow {
+    export namespace name_14 {
+        let zh_13: string;
+        export { zh_13 as zh };
+        let en_13: string;
+        export { en_13 as en };
+    }
+    export { name_14 as name };
+    let value_13: string;
+    export { value_13 as value };
+}
+import TinyColor from '../tinycolor';

package/types/url-toolkit/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/url-toolkit";
+export { "/Users/panqibao/work/ui/utils/url-toolkit/src/url-toolkit" as default } from "./src/url-toolkit";

package/types/url-toolkit/src/url-toolkit.d.ts

@@ -0,0 +1,18 @@
+declare namespace _default {
+    export { buildAbsoluteURL };
+    export { parseURL };
+    export { normalizePath };
+    export { buildURLFromParts };
+}
+export default _default;
+export function buildAbsoluteURL(baseURL: any, relativeURL: any, opts: any): any;
+export function buildURLFromParts(parts: any): any;
+export function normalizePath(path: any): any;
+export function parseURL(url: any): {
+    scheme: string;
+    netLoc: string;
+    path: string;
+    params: string;
+    query: string;
+    fragment: string;
+} | null;

package/ui-color/compareColorByRange.js

@@ -0,0 +1,9 @@
+function i(r = [34797, 15747172]) {
+  return (n = 1) => {
+    const o = r, t = Math.log(256) / Math.log(2), e = o[0] >>> t * 2 & 255, g = o[0] >>> t * 1 & 255, l = o[0] >>> t * 0 & 255, c = o[1] >>> t * 2 & 255, s = o[1] >>> t * 1 & 255, f = o[1] >>> t * 0 & 255, a = c - (c - e) * n, b = s - (s - g) * n, h = f - (f - l) * n;
+    return `rgb(${a},${b},${h})`;
+  };
+}
+export {
+  i as default
+};